From 9d540137773abbc670e4a050118858a7d0a06254 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 12:13:35 +0800 Subject: [PATCH 01/41] add GroupIndex function --- src/function/function_init.h | 2 + src/function/list_group.cc | 100 ++++++++++++++++++ test/list_group_test.cc | 200 +++++++++++++++++++++++++++++++++++ 3 files changed, 302 insertions(+) create mode 100644 src/function/list_group.cc create mode 100644 test/list_group_test.cc diff --git a/src/function/function_init.h b/src/function/function_init.h index ea5e9c4..eeadbaa 100644 --- a/src/function/function_init.h +++ b/src/function/function_init.h @@ -13,6 +13,7 @@ Status InitListArithmeticFunc(FunctionRegistry *reg); Status InitListComparisonFunc(FunctionRegistry *reg); Status InitListAggregationFunc(FunctionRegistry *reg); Status InitListBasicFunc(FunctionRegistry *reg); +Status InitListGroupFunc(FunctionRegistry *reg); Status InitMathInternalFunc(FunctionRegistry *reg); Status InitStringInternalFunc(FunctionRegistry *reg); @@ -21,6 +22,7 @@ inline Status InitListInternalFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitListComparisonFunc(reg)); JF_RETURN_NOT_OK(InitListAggregationFunc(reg)); JF_RETURN_NOT_OK(InitListBasicFunc(reg)); + JF_RETURN_NOT_OK(InitListGroupFunc(reg)); return Status::OK(); } diff --git a/src/function/list_group.cc b/src/function/list_group.cc new file mode 100644 index 0000000..ac36452 --- /dev/null +++ b/src/function/list_group.cc @@ -0,0 +1,100 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 11:35:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 11:35:00 + */ +#include +#include +#include + +#include "exec_engine.h" +#include "function_init.h" +#include "function_registry.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +namespace { + +template +U32ListStruct GroupIndex(KList keys, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + U32ListStruct result; + result.len = keys.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * keys.len)); + + std::unordered_map table; + table.reserve(keys.len * 2); + uint32_t next_id = 0; + for (uint32_t i = 0; i < keys.len; ++i) { + auto [it, inserted] = table.try_emplace(keys.data[i], next_id); + if (inserted) { + ++next_id; + } + result.data[i] = it->second; + } + return result; +} + +U32ListStruct GroupIndexString(StringListStruct keys, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + U32ListStruct result; + result.len = keys.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * keys.len)); + + std::unordered_map table; + table.reserve(static_cast(keys.len) * 2); + uint32_t next_id = 0; + for (uint32_t i = 0; i < keys.len; ++i) { + std::string_view sv(keys.data[i].data, keys.data[i].len); + auto [it, inserted] = table.try_emplace(sv, next_id); + if (inserted) { + ++next_id; + } + result.data[i] = it->second; + } + return result; +} + +} // namespace + +Status InitListGroupFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupIndex", {ValueType::kStringList, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(GroupIndexString))); + return Status::OK(); +} + +} // namespace jitfusion diff --git a/test/list_group_test.cc b/test/list_group_test.cc new file mode 100644 index 0000000..edab3ad --- /dev/null +++ b/test/list_group_test.cc @@ -0,0 +1,200 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 11:35:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 11:35:00 + */ +#include +#include +#include +#include + +#include "exec_engine.h" +#include "exec_node.h" +#include "function_registry.h" +#include "gtest/gtest.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +namespace { + +std::unique_ptr MakeGroupIndexCall(std::unique_ptr list_node) { + std::vector> args; + args.emplace_back(std::move(list_node)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); +} + +Status RunGroupIndex(std::unique_ptr expr, RetType *result) { + std::unique_ptr func_registry; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); + if (!st.ok()) { + return st; + } + ExecEngine engine; + st = engine.Compile(expr, func_registry); + if (!st.ok()) { + return st; + } + return engine.Execute(nullptr, result); +} + +} // namespace + +TEST(ListGroupTest, GroupIndexEmptyI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupIndexAllSameI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 0, 0, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexAllDistinctI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40, 50})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 2, 3, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexInterleavedI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5, 3, 5, 3})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 2, 1, 3, 0, 3, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexSingleElementI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexU8) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 5, 2, 5, 9})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 0, 1, 0, 1, 2}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexI8Negatives) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1, -2, -1, -3, -2})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexU16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{100, 200, 100, 300})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexI16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1000, 1000, -1000})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexU32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1U, 1U, 2U})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 0, 1}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexU64Large) { + auto list = std::unique_ptr(new ConstantListValueNode( + std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 1, 2}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexI64) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-9LL, 9LL, -9LL, 0LL})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexF32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1.5F, 2.5F, 1.5F, 3.5F, 2.5F})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexF64) { + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{3.14, 2.72, 3.14, 1.41, 2.72, 3.14})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexString) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"apple", "banana", "apple", "cherry", "banana", "apple"})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexStringEmpty) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupIndexStringWithEmptyStrings) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1, 0}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexStringDifferentLengths) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + std::vector expected = {0, 1, 0, 2, 1}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupIndexResultLenMatchesInputLen) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{5, 5, 5, 5, 5, 5, 5})); + RetType result; + ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get>(result).size(), 7U); +} + +} // namespace jitfusion From 925d8fca1b1812e4635d5b07883f3f57793e81db Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 16:07:33 +0800 Subject: [PATCH 02/41] add ListGroup function --- BUILD | 7 +- CMakeLists.txt | 3 +- benchmark/bench_common.h | 289 + benchmark/bench_compile.cc | 181 + benchmark/bench_execute_core.cc | 256 + benchmark/bench_list_agg.cc | 392 + benchmark/bench_list_basic.cc | 260 + benchmark/bench_list_binary.cc | 137 + benchmark/bench_list_compare.cc | 163 + benchmark/bench_native_base.cc | 218 + benchmark/engine_benchmark.cc | 1534 ---- build.log | 14783 ++++++++++++++++++++++++++++++ doc/function.md | 91 + src/function/list_group.cc | 678 +- test/list_group_test.cc | 1195 +++ 15 files changed, 18648 insertions(+), 1539 deletions(-) create mode 100644 benchmark/bench_common.h create mode 100644 benchmark/bench_compile.cc create mode 100644 benchmark/bench_execute_core.cc create mode 100644 benchmark/bench_list_agg.cc create mode 100644 benchmark/bench_list_basic.cc create mode 100644 benchmark/bench_list_binary.cc create mode 100644 benchmark/bench_list_compare.cc create mode 100644 benchmark/bench_native_base.cc delete mode 100644 benchmark/engine_benchmark.cc create mode 100644 build.log diff --git a/BUILD b/BUILD index d4fc5f3..003dcb2 100644 --- a/BUILD +++ b/BUILD @@ -18,7 +18,7 @@ cc_library( "-DNDEBUG", "-ftree-vectorize", #"-g", - #"-Rpass=loop-vectorize", + "-Rpass=loop-vectorize", "-DHAS_XSIMD", ], ) @@ -110,7 +110,10 @@ cc_test( cc_binary( name = "engine_benchmark", - srcs = ["benchmark/engine_benchmark.cc"], + srcs = glob([ + "benchmark/*.cc", + "benchmark/*.h", + ]), deps = [ ":jitfusion", ], diff --git a/CMakeLists.txt b/CMakeLists.txt index 5d967d2..cbbccf6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -196,7 +196,8 @@ endif() option(BUILD_BENCHMARK "Build google-benchmark based micro benchmarks" OFF) if(BUILD_BENCHMARK) find_package(benchmark REQUIRED) - add_executable(engine_benchmark benchmark/engine_benchmark.cc) + file(GLOB ENGINE_BENCHMARK_SRC "benchmark/*.cc" "benchmark/*.h") + add_executable(engine_benchmark ${ENGINE_BENCHMARK_SRC}) target_link_libraries(engine_benchmark jitfusion benchmark::benchmark) if(CMAKE_BUILD_TYPE STREQUAL "Debug") diff --git a/benchmark/bench_common.h b/benchmark/bench_common.h new file mode 100644 index 0000000..30a68e0 --- /dev/null +++ b/benchmark/bench_common.h @@ -0,0 +1,289 @@ +// Shared AST/registry helpers for JitFusion benchmark TUs. +// +// Splitting engine_benchmark.cc into per-category files (bench_compile.cc, +// bench_execute_core.cc, bench_list_agg.cc, ...) is purely an organisational +// change. Every TU needs the same AST-construction and registry helpers, so +// we centralise them here. +// +// Adding new benchmarks: drop a new bench_*.cc file into this directory. +// Both BUILD (glob) and CMakeLists.txt (file(GLOB ...)) pick it up +// automatically — you don't need to edit any build script. +// +// IMPORTANT: `BENCHMARK_MAIN()` must appear in exactly one TU. It currently +// lives at the bottom of bench_compile.cc. Do NOT add another BENCHMARK_MAIN +// in any other bench_*.cc — the glob-based srcs will link them all together +// and you'll get `multiple definition of main`. +// +// Every helper is marked `inline` so each TU can include this header without +// multiple-definition errors; the linker folds the copies together. +// `StoreI32` is also `inline` because some benchmarks register its address +// into a FunctionRegistry; `inline` (C++17) guarantees a single canonical +// address across the whole binary, which matters for the JIT — otherwise +// different TUs could pick different function addresses. + +#ifndef JITFUSION_BENCHMARK_BENCH_COMMON_H_ +#define JITFUSION_BENCHMARK_BENCH_COMMON_H_ + +#include + +#include +#include +#include +#include +#include +#include + +#include "exec_engine.h" +#include "exec_node.h" +#include "function_registry.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { +namespace bench { + +using ::jitfusion::BinaryOPNode; +using ::jitfusion::BinaryOPType; +using ::jitfusion::ConstantListValueNode; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecEngine; +using ::jitfusion::ExecEngineOption; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::FunctionRegistry; +using ::jitfusion::FunctionRegistryFactory; +using ::jitfusion::FunctionSignature; +using ::jitfusion::IfBlockNode; +using ::jitfusion::IfNode; +using ::jitfusion::NoOPNode; +using ::jitfusion::OutputNode; +using ::jitfusion::RefNode; +using ::jitfusion::RetType; +using ::jitfusion::SwitchNode; +using ::jitfusion::ValueType; + +// ----------------------------------------------------------------------------- +// AST construction helpers +// ----------------------------------------------------------------------------- + +// Linear chain: ((((c0 + c1) + c2) + c3) + ...) +inline std::unique_ptr MakeLinearAddChain(int depth) { + std::unique_ptr cur(new ConstantValueNode(static_cast(0))); + for (int i = 1; i <= depth; ++i) { + std::unique_ptr rhs(new ConstantValueNode(static_cast(i))); + cur = std::unique_ptr(new BinaryOPNode(BinaryOPType::kAdd, std::move(cur), std::move(rhs))); + } + return cur; +} + +// Deeply nested if-else chain: if(c,1,if(c,2,if(c,3,...))) +inline std::unique_ptr MakeDeepNestedIf(int depth) { + std::unique_ptr cur(new ConstantValueNode(static_cast(0))); + for (int i = depth; i >= 1; --i) { + std::unique_ptr cond(new ConstantValueNode(static_cast(i & 1))); + std::unique_ptr then_v(new ConstantValueNode(static_cast(i))); + std::vector> args; + args.emplace_back(std::move(cond)); + args.emplace_back(std::move(then_v)); + args.emplace_back(std::move(cur)); + cur = std::unique_ptr(new IfNode(std::move(args))); + } + return cur; +} + +// abs(abs(abs(...abs(c)))) +inline std::unique_ptr MakeManyAbsCalls(int depth) { + std::unique_ptr cur(new ConstantValueNode(static_cast(-42))); + for (int i = 0; i < depth; ++i) { + std::vector> args; + args.emplace_back(std::move(cur)); + cur = std::unique_ptr(new FunctionNode("abs", std::move(args))); + } + return cur; +} + +// Build `func_name(const_list_of_length(list_len))`. +inline std::unique_ptr MakeListUnaryCall(const std::string& func_name, int list_len) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(i); + } + std::unique_ptr list_node(new ConstantListValueNode(std::move(values))); + std::vector> args; + args.emplace_back(std::move(list_node)); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Convenience alias kept for readability. +inline std::unique_ptr MakeListSumExpr(int list_len) { return MakeListUnaryCall("Sum", list_len); } + +// Build `func_name(list, exec_ctx)` — one-arg list kernels that require an +// ExecContext pointer (arithmetic/basic kernels that allocate output lists). +inline std::unique_ptr MakeListUnaryCtxCall(const std::string& func_name, int list_len) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(i + 1); // avoid zero — log*/div-like kernels are sensitive to it. + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, exec_ctx)` — unary kernels that only accept float lists +// (ListCeil, ListFloor, ListRound). +inline std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func_name, int list_len) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(static_cast(i) + 0.5); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, scalar_int, exec_ctx)` — list-scalar broadcast. +inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_name, int list_len, int64_t scalar_val) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(i + 1); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(scalar_val)); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, scalar, exec_ctx)` — bitwise list-scalar. +// Bitwise kernels are only registered for unsigned integer types. +inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& func_name, int list_len, + uint64_t scalar_val) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(static_cast(i + 1)); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(scalar_val)); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, list, exec_ctx)` — bitwise list-list. +inline std::unique_ptr MakeListListCtxCallU64(const std::string& func_name, int list_len) { + std::vector lhs; + std::vector rhs; + lhs.reserve(list_len); + rhs.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + lhs.push_back(static_cast(i + 1)); + rhs.push_back(static_cast(list_len - i)); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(lhs))); + args.emplace_back(new ConstantListValueNode(std::move(rhs))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, list, exec_ctx)` — element-wise list-list. +inline std::unique_ptr MakeListListCtxCall(const std::string& func_name, int list_len) { + std::vector lhs; + std::vector rhs; + lhs.reserve(list_len); + rhs.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + lhs.push_back(i + 1); + rhs.push_back(list_len - i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(lhs))); + args.emplace_back(new ConstantListValueNode(std::move(rhs))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Build `func_name(list, scalar, scalar, exec_ctx)` — the IfEqual / +// IfLess / etc. family: "for each element, if cond(elem, pivot) pick a else b". +inline std::unique_ptr MakeListIfSelectCall(const std::string& func_name, int list_len) { + std::vector values; + values.reserve(list_len); + for (int i = 0; i < list_len; ++i) { + values.push_back(i + 1); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(static_cast(list_len / 2))); + args.emplace_back(new ConstantValueNode(static_cast(-1))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +inline std::unique_ptr MakeRegistry() { + std::unique_ptr r; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&r); + if (!st.ok()) { + std::abort(); + } + return r; +} + +// Side-effect sink used by benchmarks whose root otherwise would be dead-code +// eliminated (NoOPNode / IfBlockNode return void, so without a side effect +// LLVM's DCE collapses the whole entry function to `ret void` and the +// measurement reflects only the empty-JIT-call overhead, not the AST node +// under test). +// +// Must be `inline` so its address is unique across TUs that include this +// header — the JIT registry stores this address and the generated IR calls +// it by pointer. +inline void StoreI32(void* output, int32_t index, int32_t value) { + reinterpret_cast(output)[index] = value; +} + +inline std::unique_ptr MakeRegistryWithStore() { + auto r = MakeRegistry(); + FunctionSignature sig("store", {ValueType::kPtr, ValueType::kI32, ValueType::kI32}, ValueType::kVoid); + auto st = r->RegisterStoreCFunc(sig, reinterpret_cast(StoreI32), 1); + if (!st.ok()) { + std::abort(); + } + return r; +} + +// Build `store(output, index, value)` as a leaf node. Consumes the value so +// DCE can't remove it. +inline std::unique_ptr MakeStoreI32(int32_t index, std::unique_ptr value) { + std::vector> args; + args.emplace_back(new OutputNode()); + args.emplace_back(new ConstantValueNode(index)); + args.emplace_back(std::move(value)); + return std::unique_ptr(new FunctionNode("store", std::move(args))); +} + +// Compile one AST or abort. Keeps benchmark code free of ASSERT noise. +inline std::unique_ptr CompileOrDie(std::unique_ptr node, + const std::unique_ptr& reg, bool dump_ir = false) { + ExecEngineOption opt; + opt.dump_ir = dump_ir; + auto engine = std::make_unique(opt); + std::unique_ptr holder = std::move(node); + auto st = engine->Compile(holder, reg); + if (!st.ok()) { + std::abort(); + } + return engine; +} + +} // namespace bench +} // namespace jitfusion + +#endif // JITFUSION_BENCHMARK_BENCH_COMMON_H_ diff --git a/benchmark/bench_compile.cc b/benchmark/bench_compile.cc new file mode 100644 index 0000000..9e332ff --- /dev/null +++ b/benchmark/bench_compile.cc @@ -0,0 +1,181 @@ +// JitFusion engine benchmarks. +// +// Benchmark names, once merged, MUST NOT be renamed — the CI pipeline +// (benchmark-action/github-action-benchmark) keys its historical data on the +// name. Adding new cases is fine; renaming breaks the time series on gh-pages. +// +// This binary is produced from multiple translation units sharing the +// helpers in bench_common.h; every TU registers its own BENCHMARK(...) +// entries into the single benchmark::internal registry and the linker +// folds them together. BENCHMARK_MAIN() must appear in exactly one TU — +// we put it at the bottom of this file. +// +// Coverage split across files: +// A. Compile -> bench_compile.cc (this file) +// B. Execute -> bench_execute_core.cc +// C. List -> bench_list_agg.cc +// G. List basic -> bench_list_basic.cc +// H. Elem unary -> bench_list_basic.cc +// I. Elem binary -> bench_list_binary.cc +// J. Compare -> bench_list_compare.cc +// D/E/F -> bench_native_base.cc + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeDeepNestedIf; +using ::jitfusion::bench::MakeLinearAddChain; +using ::jitfusion::bench::MakeListSumExpr; +using ::jitfusion::bench::MakeManyAbsCalls; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::BinaryOPNode; +using ::jitfusion::BinaryOPType; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecEngine; +using ::jitfusion::ExecEngineOption; +using ::jitfusion::ExecNode; + +// ============================================================================= +// A. Compile +// ============================================================================= + +// A-1: Baseline compile cost for the smallest possible expression. Reflects +// the fixed LLJIT spin-up overhead. +void BM_Compile_MinimalExpr(benchmark::State& state) { + auto reg = MakeRegistry(); + for (auto _ : state) { + std::unique_ptr lhs(new ConstantValueNode(static_cast(1))); + std::unique_ptr rhs(new ConstantValueNode(static_cast(2))); + std::unique_ptr node(new BinaryOPNode(BinaryOPType::kAdd, std::move(lhs), std::move(rhs))); + ExecEngine engine; + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_MinimalExpr)->Unit(benchmark::kMillisecond); + +// A-2: Linear arithmetic chain — AST size vs compile time. +void BM_Compile_LinearChain(benchmark::State& state) { + const int depth = static_cast(state.range(0)); + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeLinearAddChain(depth); + ExecEngine engine; + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_LinearChain)->Arg(10)->Arg(100)->Arg(1000)->Unit(benchmark::kMillisecond); + +// A-3: Deeply nested if — control-flow complexity vs compile time. +void BM_Compile_DeepNested(benchmark::State& state) { + const int depth = static_cast(state.range(0)); + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeDeepNestedIf(depth); + ExecEngine engine; + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_DeepNested)->Arg(10)->Arg(50)->Arg(200)->Unit(benchmark::kMillisecond); + +// A-4: Many builtin function calls — exercises registry lookup + call-gen. +void BM_Compile_ManyFunctionCalls(benchmark::State& state) { + const int depth = static_cast(state.range(0)); + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeManyAbsCalls(depth); + ExecEngine engine; + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_ManyFunctionCalls)->Arg(10)->Arg(100)->Unit(benchmark::kMillisecond); + +// A-5: Compile cost of a list aggregation expression. +void BM_Compile_ListOps(benchmark::State& state) { + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeListSumExpr(64); + ExecEngine engine; + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_ListOps)->Unit(benchmark::kMillisecond); + +// A-6: Batch compile vs. N independent Compile() calls — measures how well the +// JIT setup amortises across multiple ASTs sharing one module. +void BM_BatchCompile(benchmark::State& state) { + const int n = static_cast(state.range(0)); + auto reg = MakeRegistry(); + for (auto _ : state) { + std::vector> nodes; + nodes.reserve(n); + for (int i = 0; i < n; ++i) { + nodes.emplace_back(MakeLinearAddChain(8)); + } + ExecEngine engine; + auto st = engine.BatchCompile(nodes, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("batch compile failed"); + } + } +} +BENCHMARK(BM_BatchCompile)->Arg(2)->Arg(8)->Arg(32)->Unit(benchmark::kMillisecond); + +// A-7: dump_ir toggle — how much does IR-text capture cost at compile time? +void BM_Compile_DumpIrOn(benchmark::State& state) { + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeLinearAddChain(32); + ExecEngineOption opt; + opt.dump_ir = true; + ExecEngine engine(opt); + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_DumpIrOn)->Unit(benchmark::kMillisecond); + +void BM_Compile_DumpIrOff(benchmark::State& state) { + auto reg = MakeRegistry(); + for (auto _ : state) { + auto node = MakeLinearAddChain(32); + ExecEngineOption opt; + opt.dump_ir = false; + ExecEngine engine(opt); + auto st = engine.Compile(node, reg); + benchmark::DoNotOptimize(st); + if (!st.ok()) { + state.SkipWithError("compile failed"); + } + } +} +BENCHMARK(BM_Compile_DumpIrOff)->Unit(benchmark::kMillisecond); + +} // namespace + +BENCHMARK_MAIN(); diff --git a/benchmark/bench_execute_core.cc b/benchmark/bench_execute_core.cc new file mode 100644 index 0000000..7e8769f --- /dev/null +++ b/benchmark/bench_execute_core.cc @@ -0,0 +1,256 @@ +// B. Execute — core (non-list) execution benchmarks. See bench_compile.cc +// for the split overview. BENCHMARK_MAIN lives in bench_compile.cc. + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeLinearAddChain; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::bench::MakeRegistryWithStore; +using ::jitfusion::bench::MakeStoreI32; +using ::jitfusion::BinaryOPNode; +using ::jitfusion::BinaryOPType; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::IfBlockNode; +using ::jitfusion::IfNode; +using ::jitfusion::NoOPNode; +using ::jitfusion::RefNode; +using ::jitfusion::RetType; +using ::jitfusion::SwitchNode; + +// ============================================================================= +// B. Execute +// ============================================================================= + +// B-1: Post-constant-fold execute — lower bound on JIT call overhead. +void BM_Execute_ConstFold(benchmark::State& state) { + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeLinearAddChain(8), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ConstFold); + +// B-2: Scalar arithmetic, representative types (i64 / f64). +// Arg(0): 0 = i64, 1 = f64 +void BM_Execute_Arith(benchmark::State& state) { + const int kind = static_cast(state.range(0)); + auto reg = MakeRegistry(); + + std::unique_ptr node; + if (kind == 0) { + std::unique_ptr l(new ConstantValueNode(static_cast(1234567))); + std::unique_ptr r(new ConstantValueNode(static_cast(7654321))); + node = std::make_unique(BinaryOPType::kMul, std::move(l), std::move(r)); + } else { + std::unique_ptr l(new ConstantValueNode(1.2345)); + std::unique_ptr r(new ConstantValueNode(6.789)); + node = std::make_unique(BinaryOPType::kMul, std::move(l), std::move(r)); + } + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_Arith)->Arg(0)->Arg(1); + +// B-3: Execute cost of a long arithmetic chain — should stay flat w.r.t. AST +// size once the JIT has folded constants. +void BM_Execute_LongChain(benchmark::State& state) { + const int depth = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeLinearAddChain(depth), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_LongChain)->Arg(10)->Arg(100)->Arg(1000); + +// B-4: Single-level if. +void BM_Execute_IfThenElse(benchmark::State& state) { + auto reg = MakeRegistry(); + std::unique_ptr cond(new ConstantValueNode(static_cast(1))); + std::unique_ptr t(new ConstantValueNode(static_cast(42))); + std::unique_ptr f(new ConstantValueNode(static_cast(-42))); + std::vector> args; + args.emplace_back(std::move(cond)); + args.emplace_back(std::move(t)); + args.emplace_back(std::move(f)); + std::unique_ptr node(new IfNode(std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_IfThenElse); + +// B-5: N-way switch. All conditions are 0 except the last, so evaluation +// traverses every branch (worst-case path). +void BM_Execute_Switch(benchmark::State& state) { + const int n = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector> args; + for (int i = 0; i < n; ++i) { + uint8_t cond_val = (i == n - 1) ? 1 : 0; + args.emplace_back(new ConstantValueNode(cond_val)); + args.emplace_back(new ConstantValueNode(static_cast(i))); + } + args.emplace_back(new ConstantValueNode(static_cast(-1))); // default + std::unique_ptr node(new SwitchNode(std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_Switch)->Arg(2)->Arg(8)->Arg(32); + +// B-6: IfBlock — multi-statement blocks. +// Args layout: [cond1, block1, cond2, block2, ..., else_block]. +// Each block binds a named `result` variable; after the IfBlock we +// store(ref("result")) so the branches are observably live. Without this +// sink LLVM would collapse the whole function to `ret void`. +void BM_Execute_IfBlock(benchmark::State& state) { + auto reg = MakeRegistryWithStore(); + + auto make_block = [](int32_t v) { + auto block = std::unique_ptr(new NoOPNode({}, {})); + static_cast(block.get())->AppendArgs("result", std::unique_ptr(new ConstantValueNode(v))); + return block; + }; + + std::vector> if_args; + if_args.emplace_back(new ConstantValueNode(static_cast(1))); + if_args.emplace_back(make_block(100)); + if_args.emplace_back(new ConstantValueNode(static_cast(0))); + if_args.emplace_back(make_block(200)); + if_args.emplace_back(make_block(300)); // else block + auto if_block = std::unique_ptr(new IfBlockNode(std::move(if_args))); + + // root = [ result = 0, , store(output, 0, ref("result")) ] + // `result` must be declared in the outer scope so RefNode("result") can + // resolve it after the IfBlock; this matches the pattern used in + // test/if_block_test.cc. + auto root = std::unique_ptr(new NoOPNode({}, {})); + static_cast(root.get()) + ->AppendArgs("result", std::unique_ptr(new ConstantValueNode(static_cast(0)))); + static_cast(root.get())->AppendArgs(std::move(if_block)); + static_cast(root.get())->AppendArgs(MakeStoreI32(0, std::unique_ptr(new RefNode("result")))); + + auto engine = CompileOrDie(std::move(root), reg); + ExecContext ctx(4096); + int32_t output = 0; + for (auto _ : state) { + ctx.Clear(); + auto st = engine->Execute(ctx, nullptr, static_cast(&output)); + benchmark::DoNotOptimize(output); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_IfBlock); + +// B-7: RefNode — common sub-expression reuse. +// Names a sub-expression via the NoOPNode named-form and references it +// through RefNode. The result of the multiplication is written out via +// `store(output, 0, ...)`; without that side effect LLVM's DCE would +// collapse the whole entry function to `ret void` because NoOPNode itself +// returns void. +void BM_Execute_RefNode(benchmark::State& state) { + auto reg = MakeRegistryWithStore(); + + // x = 10 + 20 + std::unique_ptr inner( + new BinaryOPNode(BinaryOPType::kAdd, std::unique_ptr(new ConstantValueNode(static_cast(10))), + std::unique_ptr(new ConstantValueNode(static_cast(20))))); + + // ref("x") * ref("x") + auto product = std::unique_ptr(new BinaryOPNode( + BinaryOPType::kMul, std::unique_ptr(new RefNode("x")), std::unique_ptr(new RefNode("x")))); + + std::vector names = {"x", ""}; + std::vector> items; + items.emplace_back(std::move(inner)); + items.emplace_back(MakeStoreI32(0, std::move(product))); + std::unique_ptr node(new NoOPNode(std::move(names), std::move(items))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + int32_t output = 0; + for (auto _ : state) { + ctx.Clear(); + auto st = engine->Execute(ctx, nullptr, static_cast(&output)); + benchmark::DoNotOptimize(output); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_RefNode); + +// B-8: Builtin function-call execute cost (abs). +void BM_Execute_FunctionCall_Builtin(benchmark::State& state) { + auto reg = MakeRegistry(); + std::unique_ptr arg(new ConstantValueNode(static_cast(-12345))); + std::vector> args; + args.emplace_back(std::move(arg)); + std::unique_ptr node(new FunctionNode("abs", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_FunctionCall_Builtin); + +} // namespace diff --git a/benchmark/bench_list_agg.cc b/benchmark/bench_list_agg.cc new file mode 100644 index 0000000..8073fac --- /dev/null +++ b/benchmark/bench_list_agg.cc @@ -0,0 +1,392 @@ +// C. List aggregation + C-group. See bench_compile.cc for the split overview. + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::ConstantListValueNode; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::RetType; + +// ============================================================================= +// C. List aggregation — kernel cost vs. list length +// ============================================================================= +// +// These cases share a single shape (aggregate kernel called on a constant +// int64 list) and vary only the length. Names and argument lists are fixed +// because gh-pages indexes by the full name incl. "/N". + +void BM_Execute_ListSum(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Sum", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSum)->Arg(16)->Arg(256)->Arg(4096); + +void BM_Execute_ListMax(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Max", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListMax)->Arg(16)->Arg(256)->Arg(4096); + +void BM_Execute_ListAvg(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Avg", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListAvg)->Arg(16)->Arg(256)->Arg(4096); + +// ----------------------------------------------------------------------------- +// C-extra: remaining aggregation kernels. +// Every kernel gets its own benchmark name so gh-pages can plot it +// independently. Two list lengths (256, 4096) are enough to distinguish +// O(N) kernels from O(N log N) / O(N^2) ones. +// ----------------------------------------------------------------------------- + +void BM_Execute_ListMin(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Min", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListMin)->Arg(256)->Arg(4096); + +void BM_Execute_ListMedian(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Median", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListMedian)->Arg(256)->Arg(4096); + +void BM_Execute_ListSortedMedian(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("SortedMedian", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSortedMedian)->Arg(256)->Arg(4096); + +void BM_Execute_ListCountDistinct(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("CountDistinct", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListCountDistinct)->Arg(256)->Arg(4096); + +// CountBits is only registered for U8List. +void BM_Execute_ListCountBits(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector values(len, static_cast(0xA5)); + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + std::unique_ptr node(new FunctionNode("CountBits", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListCountBits)->Arg(256)->Arg(4096); + +// GetAt(list, 0) — random access cost, should be O(1). +void BM_Execute_ListGetAt(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(static_cast(0))); + std::unique_ptr node(new FunctionNode("GetAt", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListGetAt)->Arg(256)->Arg(4096); + +// ----------------------------------------------------------------------------- +// C-group: group-aggregation kernels. +// +// These functions share a common shape: a keys/values list drives a scatter +// aggregation over `distinct` buckets. Cost depends on both the input length +// and the distinct-bucket count, so each case is parameterised on two +// dimensions via Args({len, distinct}). +// +// The synthetic keys list is [0, 1, ..., distinct-1, 0, 1, ...] repeated up +// to `len`, so the produced group ids are stable regardless of hash-map +// iteration order. +// +// Three profile points cover the meaningful regimes: +// * {4096, 16} — large batch, very few groups (cache-friendly scatter). +// * {4096, 256} — large batch, moderate group count. +// * {4096, 4096} — every element is its own group (worst-case hash churn). +// +// Only the sugar (3-arg) form is benchmarked: that is what user code calls, +// and it implicitly exercises the internal GroupCount CSE node as well. +// ----------------------------------------------------------------------------- + +// Build a keys list with `len` int64 elements whose values cycle through +// [0, distinct). Good enough to drive every group kernel deterministically. +std::unique_ptr MakeGroupKeysList(int len, int distinct) { + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(static_cast(i % distinct)); + } + return std::unique_ptr(new ConstantListValueNode(std::move(values))); +} + +// Build `GroupIndex(keys_list, exec_ctx)` — the only non-sugar group node in +// the family; its kernel is the 2-arg form. +std::unique_ptr MakeGroupIndexNode(int len, int distinct) { + std::vector> args; + args.emplace_back(MakeGroupKeysList(len, distinct)); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); +} + +// C-group-1: GroupIndex standalone — hash-map construction cost. +void BM_Execute_GroupIndex(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupIndexNode(len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupIndex)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// C-group-2: GroupCount(GroupIndex(keys)) — the max-scan reduction. +// This isolates the CSE target shared by every sugar in the family. +void BM_Execute_GroupCount(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + std::vector> args; + args.emplace_back(MakeGroupIndexNode(len, distinct)); + std::unique_ptr node(new FunctionNode("GroupCount", std::move(args))); + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupCount)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...), exec_ctx)`. +// The keys list drives GroupIndex; the same list is also fed as values/keys +// to the aggregate under test. That's fine because all aggregates accept +// integer lists and we measure compute time, not numerical content. +std::unique_ptr MakeGroupSugarCall(const std::string& func_name, int len, int distinct) { + std::vector> args; + args.emplace_back(MakeGroupKeysList(len, distinct)); + args.emplace_back(MakeGroupIndexNode(len, distinct)); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// C-group-3: GroupKeys sugar — keys + group_index → per-bucket first-seen key. +void BM_Execute_GroupKeys(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupSugarCall("GroupKeys", len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupKeys)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// C-group-4: GroupSum sugar — scatter-add with int-to-i64 promotion. +void BM_Execute_GroupSum(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupSugarCall("GroupSum", len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupSum)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// C-group-5: GroupMax sugar — scatter-max with lowest() seed. +void BM_Execute_GroupMax(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupSugarCall("GroupMax", len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupMax)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// C-group-6: GroupMin sugar — scatter-min with max() seed. +void BM_Execute_GroupMin(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupSugarCall("GroupMin", len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupMin)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +// C-group-7: GroupAvg sugar — scatter-sum + per-bucket divide (f64 output). +void BM_Execute_GroupAvg(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int distinct = static_cast(state.range(1)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeGroupSugarCall("GroupAvg", len, distinct), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_GroupAvg)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); + +} // namespace diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc new file mode 100644 index 0000000..6585ec6 --- /dev/null +++ b/benchmark/bench_list_basic.cc @@ -0,0 +1,260 @@ +// G. List basic (shape manipulation) + H. List element-wise unary. +// See bench_compile.cc for the split overview. + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListListCtxCall; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeListUnaryCtxCall; +using ::jitfusion::bench::MakeListUnaryCtxCallF64; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::ConstantListValueNode; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::RetType; + +// ============================================================================= +// G. List basic — shape-manipulation kernels +// ============================================================================= + +// Len is O(1); one length sample is enough. +void BM_Execute_ListLen(benchmark::State& state) { + auto reg = MakeRegistry(); + std::vector values(256, 0); + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + std::unique_ptr node(new FunctionNode("Len", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListLen); + +void BM_Execute_ListUnique(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCtxCall("Unique", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListUnique)->Arg(256)->Arg(4096); + +void BM_Execute_ListSortAsc(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCtxCall("SortAsc", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSortAsc)->Arg(256)->Arg(4096); + +void BM_Execute_ListSortDesc(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCtxCall("SortDesc", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSortDesc)->Arg(256)->Arg(4096); + +// Truncate takes (list, u32) — keep the first `keep_n` elements. +void BM_Execute_ListTruncate(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(static_cast(len / 2))); + std::unique_ptr node(new FunctionNode("Truncate", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListTruncate)->Arg(256)->Arg(4096); + +void BM_Execute_ListCastStringList(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCtxCall("CastStringList", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListCastStringList)->Arg(256)->Arg(4096); + +void BM_Execute_ListMurmurHash3X8632(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("MurmurHash3X8632", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListMurmurHash3X8632)->Arg(256)->Arg(4096); + +// ListConcat(listA, listB, ctx). +void BM_Execute_ListConcat(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListListCtxCall("ListConcat", len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096); + +// `in(needle, haystack_list)` — scalar-in-list membership test (not list-out). +void BM_Execute_ListIn(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(i); + } + std::vector> args; + // Search for a value near the end to force worst-case linear scan. + args.emplace_back(new ConstantValueNode(static_cast(len - 1))); + args.emplace_back(new ConstantListValueNode(std::move(values))); + std::unique_ptr node(new FunctionNode("in", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListIn)->Arg(256)->Arg(4096); + +// ============================================================================= +// H. List element-wise unary (func(list, ctx) -> list) +// ============================================================================= + +#define JITFUSION_DEFINE_LIST_UNARY_BM(NAME) \ + void BM_Execute_##NAME(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListUnaryCtxCall(#NAME, len), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME)->Arg(256)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_UNARY_BM(ListExp); +JITFUSION_DEFINE_LIST_UNARY_BM(ListLog); +JITFUSION_DEFINE_LIST_UNARY_BM(ListLog2); +JITFUSION_DEFINE_LIST_UNARY_BM(ListLog10); +#undef JITFUSION_DEFINE_LIST_UNARY_BM + +// ListCeil / ListFloor / ListRound only accept float lists. +#define JITFUSION_DEFINE_LIST_UNARY_F64_BM(NAME) \ + void BM_Execute_##NAME(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListUnaryCtxCallF64(#NAME, len), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME)->Arg(256)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListCeil); +JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListFloor); +JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListRound); + +#undef JITFUSION_DEFINE_LIST_UNARY_F64_BM + +} // namespace diff --git a/benchmark/bench_list_binary.cc b/benchmark/bench_list_binary.cc new file mode 100644 index 0000000..22cb915 --- /dev/null +++ b/benchmark/bench_list_binary.cc @@ -0,0 +1,137 @@ +// I. List element-wise binary — two shapes (scalar broadcast + list-list zip). +// See bench_compile.cc for the split overview. + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListListCtxCall; +using ::jitfusion::bench::MakeListListCtxCallU64; +using ::jitfusion::bench::MakeListScalarCtxCall; +using ::jitfusion::bench::MakeListScalarCtxCallU64; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::ExecContext; +using ::jitfusion::RetType; + +// ============================================================================= +// I. List element-wise binary — two shapes +// ============================================================================= +// +// Every kernel in this family is overloaded for both: +// - `Scalar` : list OP scalar -> list (broadcast) +// - `LL` : list OP list -> list (zip) +// Both shapes are exercised so we can see whether the list-list path takes +// a different code branch (e.g. lacks vectorisation). + +#define JITFUSION_DEFINE_LIST_BINARY_BM(NAME) \ + void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, 2), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096); \ + void BM_Execute_##NAME##_LL(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListListCtxCall(#NAME, len), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME##_LL)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_BINARY_BM(ListAdd); +JITFUSION_DEFINE_LIST_BINARY_BM(ListSub); +JITFUSION_DEFINE_LIST_BINARY_BM(ListMul); +JITFUSION_DEFINE_LIST_BINARY_BM(ListDiv); +JITFUSION_DEFINE_LIST_BINARY_BM(ListMod); +#undef JITFUSION_DEFINE_LIST_BINARY_BM + +// ListMax / ListMin are only registered in the list-scalar (broadcast) form: +// there is no list-list overload in the current function registry. Exercising +// the `_LL` variant would cause Compile() to fail (no matching signature), +// which in turn aborts the whole benchmark binary via CompileOrDie(). Keep +// only the scalar shape here — if list-list versions get added later, move +// these two back into JITFUSION_DEFINE_LIST_BINARY_BM. +#define JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(NAME) \ + void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, 2), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(ListMax); +JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(ListMin); +#undef JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM + +// Bitwise kernels are only registered for unsigned integer types. +#define JITFUSION_DEFINE_LIST_BITWISE_BM(NAME) \ + void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListScalarCtxCallU64(#NAME, len, 0xFFULL), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096); \ + void BM_Execute_##NAME##_LL(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListListCtxCallU64(#NAME, len), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME##_LL)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseAnd); +JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseOr); +JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseXor); + +#undef JITFUSION_DEFINE_LIST_BITWISE_BM + +} // namespace diff --git a/benchmark/bench_list_compare.cc b/benchmark/bench_list_compare.cc new file mode 100644 index 0000000..ce6febf --- /dev/null +++ b/benchmark/bench_list_compare.cc @@ -0,0 +1,163 @@ +// J. List comparison / bitmap kernels. See bench_compile.cc for the overview. + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListIfSelectCall; +using ::jitfusion::bench::MakeListScalarCtxCall; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::ConstantListValueNode; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::RetType; + +// ============================================================================= +// J. List comparison / bitmap kernels +// ============================================================================= +// +// Two sub-families here: +// - `Gen*Bitmap(list, pivot, ctx)` : produce a U8List bitmap. +// - `If*(list, pivot, alt, ctx)` : pick from `list` vs `alt` per element. +// Plus two helpers that consume a bitmap: `IfByBitmap`, `FilterByBitmap`. + +#define JITFUSION_DEFINE_LIST_GENBITMAP_BM(NAME) \ + void BM_Execute_##NAME(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, len / 2), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenEqualBitmap); +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenNotEqualBitmap); +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLargeBitmap); +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLargeEqualBitmap); +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLessBitmap); +JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLessEqualBitmap); + +#undef JITFUSION_DEFINE_LIST_GENBITMAP_BM + +#define JITFUSION_DEFINE_LIST_IFSELECT_BM(NAME) \ + void BM_Execute_##NAME(benchmark::State& state) { \ + const int len = static_cast(state.range(0)); \ + auto reg = MakeRegistry(); \ + auto engine = CompileOrDie(MakeListIfSelectCall(#NAME, len), reg); \ + ExecContext ctx(4096); \ + for (auto _ : state) { \ + ctx.Clear(); \ + RetType result; \ + auto st = engine->Execute(ctx, nullptr, &result); \ + benchmark::DoNotOptimize(result); \ + if (!st.ok()) { \ + state.SkipWithError("execute failed"); \ + } \ + } \ + } \ + BENCHMARK(BM_Execute_##NAME)->Arg(4096) // NOLINT + +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfEqual); +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfNotEqual); +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLarge); +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLargeEqual); +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLess); +JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLessEqual); + +#undef JITFUSION_DEFINE_LIST_IFSELECT_BM + +// IfByBitmap(packed_bitmap, value_list, alt_scalar, ctx). +// For each element i: packed_bitmap bit i set ? value_list[i] : alt_scalar. +// `packed_bitmap` is a U8List of ceil(len/8) bytes, LSB = first element. +void BM_Execute_IfByBitmap(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int bitmap_bytes = (len + 7) / 8; + auto reg = MakeRegistry(); + std::vector bitmap(bitmap_bytes, static_cast(0x55)); // every other bit set + std::vector values(len); + for (int i = 0; i < len; ++i) { + values[i] = i; + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(bitmap))); + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantValueNode(static_cast(-1))); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("IfByBitmap", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_IfByBitmap)->Arg(4096); + +// FilterByBitmap(value_list, packed_bitmap, popcount, ctx). +// +// NOTE: unlike IfByBitmap (whose U8List is a per-element 0/1 array), here the +// bitmap is a *packed* bitmap — each byte encodes 8 elements (LSB = first +// element). So its length must be exactly ceil(values.size() / 8), and +// `popcnt` is the number of 1-bits across all bytes. Using a per-element +// bitmap triggers "bitmap len is not corresponding to list len" at runtime. +// Using 0x55 (0b01010101) gives 4 ones per byte → every other element kept. +void BM_Execute_FilterByBitmap(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int bitmap_bytes = (len + 7) / 8; + auto reg = MakeRegistry(); + std::vector values(len); + std::vector bitmap(bitmap_bytes, static_cast(0x55)); + uint32_t popcnt = 0; + for (int i = 0; i < len; ++i) { + values[i] = i; + } + // Count set bits per byte. This runs once during benchmark setup, not in + // the timed loop, so a plain portable loop is fine — no need for + // __builtin_popcount / std::popcount. + for (int b = 0; b < bitmap_bytes; ++b) { + uint8_t byte = bitmap[b]; + while (byte != 0) { + popcnt += static_cast(byte & 1U); + byte = static_cast(byte >> 1); + } + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantListValueNode(std::move(bitmap))); + args.emplace_back(new ConstantValueNode(popcnt)); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("FilterByBitmap", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_FilterByBitmap)->Arg(4096); + +} // namespace diff --git a/benchmark/bench_native_base.cc b/benchmark/bench_native_base.cc new file mode 100644 index 0000000..d81e976 --- /dev/null +++ b/benchmark/bench_native_base.cc @@ -0,0 +1,218 @@ +// D. ExecContext arena reuse vs fresh. +// E. Batch execute (ExecuteAll / ExecuteAt loop). +// F. Hand-written native C++ baselines. +// See bench_compile.cc for the overview. + +#include + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeLinearAddChain; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecEngine; +using ::jitfusion::ExecNode; +using ::jitfusion::RetType; + +// ============================================================================= +// D. ExecContext reuse — arena allocator cost +// ============================================================================= +// +// Same AST, same engine, two call patterns: +// - Reuse: one ExecContext is shared across iterations, Clear()'d each time +// → arena memory from the first iteration is kept and reused. +// - Fresh: a new ExecContext is constructed every iteration +// → arena allocator starts from scratch, paying first-chunk malloc cost. +// The gap is the payoff of the ExecContext& Execute overload on hot paths. + +void BM_Execute_ArenaReuse(benchmark::State& state) { + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeLinearAddChain(8), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ArenaReuse); + +void BM_Execute_ArenaFresh(benchmark::State& state) { + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeLinearAddChain(8), reg); + for (auto _ : state) { + ExecContext ctx(4096); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ArenaFresh); + +// Same pair, but with a list aggregation that forces real arena usage +// (list materialisation + kernel scratch space), so the reuse / fresh gap +// is more visible than in the const-fold case above. +void BM_Execute_ListSum_ArenaReuse(benchmark::State& state) { + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Sum", 256), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSum_ArenaReuse); + +void BM_Execute_ListSum_ArenaFresh(benchmark::State& state) { + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeListUnaryCall("Sum", 256), reg); + for (auto _ : state) { + ExecContext ctx(4096); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListSum_ArenaFresh); + +// ============================================================================= +// E. Batch execute +// ============================================================================= +// +// BatchCompile N ASTs once, then measure only the per-iteration execute +// cost. Two access patterns: +// - ExecuteAll: hand the vector back in one call. +// - ExecuteAtLoop: call ExecuteAt(i) in a loop on the benchmark side. +// The two should be close; a large gap would point at per-call overhead in +// the wrapper layer. + +void BM_BatchExecute_All(benchmark::State& state) { + const int n = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector> nodes; + nodes.reserve(n); + for (int i = 0; i < n; ++i) { + nodes.emplace_back(MakeLinearAddChain(8)); + } + ExecEngine engine; + auto cs = engine.BatchCompile(nodes, reg); + if (!cs.ok()) { + state.SkipWithError("batch compile failed"); + return; + } + ExecContext ctx(4096); + std::vector results; + for (auto _ : state) { + ctx.Clear(); + results.clear(); + auto st = engine.ExecuteAll(ctx, nullptr, &results); + benchmark::DoNotOptimize(results); + if (!st.ok()) { + state.SkipWithError("execute all failed"); + } + } +} +BENCHMARK(BM_BatchExecute_All)->Arg(2)->Arg(8)->Arg(32); + +void BM_BatchExecute_AtLoop(benchmark::State& state) { + const int n = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector> nodes; + nodes.reserve(n); + for (int i = 0; i < n; ++i) { + nodes.emplace_back(MakeLinearAddChain(8)); + } + ExecEngine engine; + auto cs = engine.BatchCompile(nodes, reg); + if (!cs.ok()) { + state.SkipWithError("batch compile failed"); + return; + } + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + for (int i = 0; i < n; ++i) { + RetType result; + auto st = engine.ExecuteAt(static_cast(i), ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute_at failed"); + break; + } + } + } +} +BENCHMARK(BM_BatchExecute_AtLoop)->Arg(2)->Arg(8)->Arg(32); + +// ============================================================================= +// F. Native C++ baselines +// ============================================================================= +// +// Hand-written C++ counterparts of selected B/C cases. They give a concrete +// "zero-overhead" reference point so the engine's numbers can be read as +// "JIT overhead over optimal native". +// +// NOTE: gh-pages plots the raw times, so do NOT rename these — the pairing +// with the engine variants (e.g. BM_Execute_Arith/0 vs BM_Native_Arith_i64) +// is implicit in the name. If you add a new engine variant, add its native +// twin right next to it. + +void BM_Native_Arith_i64(benchmark::State& state) { + int64_t a = 1234567; + int64_t b = 7654321; + for (auto _ : state) { + benchmark::DoNotOptimize(a); + benchmark::DoNotOptimize(b); + int64_t r = a * b; + benchmark::DoNotOptimize(r); + } +} +BENCHMARK(BM_Native_Arith_i64); + +void BM_Native_Arith_f64(benchmark::State& state) { + double a = 1.2345; + double b = 6.789; + for (auto _ : state) { + benchmark::DoNotOptimize(a); + benchmark::DoNotOptimize(b); + double r = a * b; + benchmark::DoNotOptimize(r); + } +} +BENCHMARK(BM_Native_Arith_f64); + +void BM_Native_ListSum_i64(benchmark::State& state) { + const int len = static_cast(state.range(0)); + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(i); + } + for (auto _ : state) { + benchmark::DoNotOptimize(values.data()); + int64_t sum = std::accumulate(values.begin(), values.end(), int64_t{0}); + benchmark::DoNotOptimize(sum); + } +} +BENCHMARK(BM_Native_ListSum_i64)->Arg(16)->Arg(256)->Arg(4096); + +} // namespace diff --git a/benchmark/engine_benchmark.cc b/benchmark/engine_benchmark.cc deleted file mode 100644 index 7aea2b3..0000000 --- a/benchmark/engine_benchmark.cc +++ /dev/null @@ -1,1534 +0,0 @@ -// JitFusion engine benchmarks. -// -// Benchmark names, once merged, MUST NOT be renamed — the CI pipeline -// (benchmark-action/github-action-benchmark) keys its historical data on the -// name. Adding new cases is fine; renaming breaks the time series on gh-pages. -// -// Coverage: -// A. Compile : MinimalExpr / LinearChain / DeepNested / ManyFunctionCalls -// / ListOps / BatchCompile / DumpIr on-off -// B. Execute : ConstFold / Arith (parameterised per type) / LongChain -// / IfThenElse / Switch / IfBlock / RefNode / FunctionCall -// C. List : full aggregation surface — Sum / Max / Min / Avg / Median -// / SortedMedian / CountDistinct / CountBits / GetAt -// G. List basic : Len / Unique / SortAsc / SortDesc / Truncate / -// CastStringList / MurmurHash3X8632 / ListConcat / in -// H. Elem unary : ListExp / Log / Log2 / Log10 / Ceil / Floor / Round -// I. Elem binary : ListAdd / Sub / Mul / Div / Mod / Max / Min / -// BitwiseAnd / Or / Xor, each in Scalar and list-list forms -// J. Compare : Gen{Equal,NotEqual,Large,LargeEqual,Less,LessEqual}Bitmap -// / If{Equal,NotEqual,Large,LargeEqual,Less,LessEqual} -// / IfByBitmap / FilterByBitmap -// D. ExecContext : arena reuse vs. fresh-per-call -// E. Batch : ExecuteAll / ExecuteAt loop after BatchCompile -// F. Native base : hand-written C++ baselines to calibrate JIT overhead - -#include - -#include -#include -#include -#include -#include -#include - -#include "exec_engine.h" -#include "exec_node.h" -#include "function_registry.h" -#include "status.h" -#include "type.h" - -namespace { - -using jitfusion::BinaryOPNode; -using jitfusion::BinaryOPType; -using jitfusion::ConstantListValueNode; -using jitfusion::ConstantValueNode; -using jitfusion::ExecContext; -using jitfusion::ExecEngine; -using jitfusion::ExecEngineOption; -using jitfusion::ExecNode; -using jitfusion::FunctionNode; -using jitfusion::FunctionRegistry; -using jitfusion::FunctionRegistryFactory; -using jitfusion::FunctionSignature; -using jitfusion::IfBlockNode; -using jitfusion::IfNode; -using jitfusion::NoOPNode; -using jitfusion::OutputNode; -using jitfusion::RefNode; -using jitfusion::RetType; -using jitfusion::SwitchNode; -using jitfusion::ValueType; - -// ----------------------------------------------------------------------------- -// AST construction helpers -// ----------------------------------------------------------------------------- - -// Linear chain: ((((c0 + c1) + c2) + c3) + ...) -std::unique_ptr MakeLinearAddChain(int depth) { - std::unique_ptr cur(new ConstantValueNode(static_cast(0))); - for (int i = 1; i <= depth; ++i) { - std::unique_ptr rhs(new ConstantValueNode(static_cast(i))); - cur = std::unique_ptr(new BinaryOPNode(BinaryOPType::kAdd, std::move(cur), std::move(rhs))); - } - return cur; -} - -// Deeply nested if-else chain: if(c,1,if(c,2,if(c,3,...))) -std::unique_ptr MakeDeepNestedIf(int depth) { - std::unique_ptr cur(new ConstantValueNode(static_cast(0))); - for (int i = depth; i >= 1; --i) { - std::unique_ptr cond(new ConstantValueNode(static_cast(i & 1))); - std::unique_ptr then_v(new ConstantValueNode(static_cast(i))); - std::vector> args; - args.emplace_back(std::move(cond)); - args.emplace_back(std::move(then_v)); - args.emplace_back(std::move(cur)); - cur = std::unique_ptr(new IfNode(std::move(args))); - } - return cur; -} - -// abs(abs(abs(...abs(c)))) -std::unique_ptr MakeManyAbsCalls(int depth) { - std::unique_ptr cur(new ConstantValueNode(static_cast(-42))); - for (int i = 0; i < depth; ++i) { - std::vector> args; - args.emplace_back(std::move(cur)); - cur = std::unique_ptr(new FunctionNode("abs", std::move(args))); - } - return cur; -} - -// Build `func_name(const_list_of_length(list_len))`. -std::unique_ptr MakeListUnaryCall(const std::string& func_name, int list_len) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(i); - } - std::unique_ptr list_node(new ConstantListValueNode(std::move(values))); - std::vector> args; - args.emplace_back(std::move(list_node)); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Convenience alias kept for readability. -std::unique_ptr MakeListSumExpr(int list_len) { return MakeListUnaryCall("Sum", list_len); } - -// Build `func_name(list, exec_ctx)` — one-arg list kernels that require an -// ExecContext pointer (arithmetic/basic kernels that allocate output lists). -std::unique_ptr MakeListUnaryCtxCall(const std::string& func_name, int list_len) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(i + 1); // avoid zero — log*/div-like kernels are sensitive to it. - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, exec_ctx)` — unary kernels that only accept float lists -// (ListCeil, ListFloor, ListRound). -std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func_name, int list_len) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(static_cast(i) + 0.5); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, scalar_int, exec_ctx)` — list-scalar broadcast. -std::unique_ptr MakeListScalarCtxCall(const std::string& func_name, int list_len, int64_t scalar_val) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(i + 1); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, scalar, exec_ctx)` — bitwise list-scalar. -// Bitwise kernels are only registered for unsigned integer types. -std::unique_ptr MakeListScalarCtxCallU64(const std::string& func_name, int list_len, uint64_t scalar_val) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(static_cast(i + 1)); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, list, exec_ctx)` — bitwise list-list. -std::unique_ptr MakeListListCtxCallU64(const std::string& func_name, int list_len) { - std::vector lhs; - std::vector rhs; - lhs.reserve(list_len); - rhs.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - lhs.push_back(static_cast(i + 1)); - rhs.push_back(static_cast(list_len - i)); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(lhs))); - args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, list, exec_ctx)` — element-wise list-list. -std::unique_ptr MakeListListCtxCall(const std::string& func_name, int list_len) { - std::vector lhs; - std::vector rhs; - lhs.reserve(list_len); - rhs.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - lhs.push_back(i + 1); - rhs.push_back(list_len - i); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(lhs))); - args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -// Build `func_name(list, scalar, scalar, exec_ctx)` — the IfEqual / -// IfLess / etc. family: "for each element, if cond(elem, pivot) pick a else b". -std::unique_ptr MakeListIfSelectCall(const std::string& func_name, int list_len) { - std::vector values; - values.reserve(list_len); - for (int i = 0; i < list_len; ++i) { - values.push_back(i + 1); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(static_cast(list_len / 2))); - args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); - return std::unique_ptr(new FunctionNode(func_name, std::move(args))); -} - -std::unique_ptr MakeRegistry() { - std::unique_ptr r; - auto st = FunctionRegistryFactory::CreateFunctionRegistry(&r); - if (!st.ok()) { - std::abort(); - } - return r; -} - -// Side-effect sink used by benchmarks whose root otherwise would be dead-code -// eliminated (NoOPNode / IfBlockNode return void, so without a side effect -// LLVM's DCE collapses the whole entry function to `ret void` and the -// measurement reflects only the empty-JIT-call overhead, not the AST node -// under test). -void StoreI32(void* output, int32_t index, int32_t value) { reinterpret_cast(output)[index] = value; } - -std::unique_ptr MakeRegistryWithStore() { - auto r = MakeRegistry(); - FunctionSignature sig("store", {ValueType::kPtr, ValueType::kI32, ValueType::kI32}, ValueType::kVoid); - auto st = r->RegisterStoreCFunc(sig, reinterpret_cast(StoreI32), 1); - if (!st.ok()) { - std::abort(); - } - return r; -} - -// Build `store(output, index, value)` as a leaf node. Consumes the value so -// DCE can't remove it. -std::unique_ptr MakeStoreI32(int32_t index, std::unique_ptr value) { - std::vector> args; - args.emplace_back(new OutputNode()); - args.emplace_back(new ConstantValueNode(index)); - args.emplace_back(std::move(value)); - return std::unique_ptr(new FunctionNode("store", std::move(args))); -} - -// Compile one AST or abort. Keeps benchmark code free of ASSERT noise. -std::unique_ptr CompileOrDie(std::unique_ptr node, const std::unique_ptr& reg, - bool dump_ir = false) { - ExecEngineOption opt; - opt.dump_ir = dump_ir; - auto engine = std::make_unique(opt); - std::unique_ptr holder = std::move(node); - auto st = engine->Compile(holder, reg); - if (!st.ok()) { - std::abort(); - } - return engine; -} - -// ============================================================================= -// A. Compile -// ============================================================================= - -// A-1: Baseline compile cost for the smallest possible expression. Reflects -// the fixed LLJIT spin-up overhead. -void BM_Compile_MinimalExpr(benchmark::State& state) { - auto reg = MakeRegistry(); - for (auto _ : state) { - std::unique_ptr lhs(new ConstantValueNode(static_cast(1))); - std::unique_ptr rhs(new ConstantValueNode(static_cast(2))); - std::unique_ptr node(new BinaryOPNode(BinaryOPType::kAdd, std::move(lhs), std::move(rhs))); - ExecEngine engine; - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_MinimalExpr)->Unit(benchmark::kMillisecond); - -// A-2: Linear arithmetic chain — AST size vs compile time. -void BM_Compile_LinearChain(benchmark::State& state) { - const int depth = static_cast(state.range(0)); - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeLinearAddChain(depth); - ExecEngine engine; - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_LinearChain)->Arg(10)->Arg(100)->Arg(1000)->Unit(benchmark::kMillisecond); - -// A-3: Deeply nested if — control-flow complexity vs compile time. -void BM_Compile_DeepNested(benchmark::State& state) { - const int depth = static_cast(state.range(0)); - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeDeepNestedIf(depth); - ExecEngine engine; - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_DeepNested)->Arg(10)->Arg(50)->Arg(200)->Unit(benchmark::kMillisecond); - -// A-4: Many builtin function calls — exercises registry lookup + call-gen. -void BM_Compile_ManyFunctionCalls(benchmark::State& state) { - const int depth = static_cast(state.range(0)); - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeManyAbsCalls(depth); - ExecEngine engine; - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_ManyFunctionCalls)->Arg(10)->Arg(100)->Unit(benchmark::kMillisecond); - -// A-5: Compile cost of a list aggregation expression. -void BM_Compile_ListOps(benchmark::State& state) { - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeListSumExpr(64); - ExecEngine engine; - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_ListOps)->Unit(benchmark::kMillisecond); - -// A-6: Batch compile vs. N independent Compile() calls — measures how well the -// JIT setup amortises across multiple ASTs sharing one module. -void BM_BatchCompile(benchmark::State& state) { - const int n = static_cast(state.range(0)); - auto reg = MakeRegistry(); - for (auto _ : state) { - std::vector> nodes; - nodes.reserve(n); - for (int i = 0; i < n; ++i) { - nodes.emplace_back(MakeLinearAddChain(8)); - } - ExecEngine engine; - auto st = engine.BatchCompile(nodes, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("batch compile failed"); - } - } -} -BENCHMARK(BM_BatchCompile)->Arg(2)->Arg(8)->Arg(32)->Unit(benchmark::kMillisecond); - -// A-7: dump_ir toggle — how much does IR-text capture cost at compile time? -void BM_Compile_DumpIrOn(benchmark::State& state) { - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeLinearAddChain(32); - ExecEngineOption opt; - opt.dump_ir = true; - ExecEngine engine(opt); - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_DumpIrOn)->Unit(benchmark::kMillisecond); - -void BM_Compile_DumpIrOff(benchmark::State& state) { - auto reg = MakeRegistry(); - for (auto _ : state) { - auto node = MakeLinearAddChain(32); - ExecEngineOption opt; - opt.dump_ir = false; - ExecEngine engine(opt); - auto st = engine.Compile(node, reg); - benchmark::DoNotOptimize(st); - if (!st.ok()) { - state.SkipWithError("compile failed"); - } - } -} -BENCHMARK(BM_Compile_DumpIrOff)->Unit(benchmark::kMillisecond); - -// ============================================================================= -// B. Execute -// ============================================================================= - -// B-1: Post-constant-fold execute — lower bound on JIT call overhead. -void BM_Execute_ConstFold(benchmark::State& state) { - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeLinearAddChain(8), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ConstFold); - -// B-2: Scalar arithmetic, representative types (i64 / f64). -// Arg(0): 0 = i64, 1 = f64 -void BM_Execute_Arith(benchmark::State& state) { - const int kind = static_cast(state.range(0)); - auto reg = MakeRegistry(); - - std::unique_ptr node; - if (kind == 0) { - std::unique_ptr l(new ConstantValueNode(static_cast(1234567))); - std::unique_ptr r(new ConstantValueNode(static_cast(7654321))); - node = std::make_unique(BinaryOPType::kMul, std::move(l), std::move(r)); - } else { - std::unique_ptr l(new ConstantValueNode(1.2345)); - std::unique_ptr r(new ConstantValueNode(6.789)); - node = std::make_unique(BinaryOPType::kMul, std::move(l), std::move(r)); - } - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_Arith)->Arg(0)->Arg(1); - -// B-3: Execute cost of a long arithmetic chain — should stay flat w.r.t. AST -// size once the JIT has folded constants. -void BM_Execute_LongChain(benchmark::State& state) { - const int depth = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeLinearAddChain(depth), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_LongChain)->Arg(10)->Arg(100)->Arg(1000); - -// B-4: Single-level if. -void BM_Execute_IfThenElse(benchmark::State& state) { - auto reg = MakeRegistry(); - std::unique_ptr cond(new ConstantValueNode(static_cast(1))); - std::unique_ptr t(new ConstantValueNode(static_cast(42))); - std::unique_ptr f(new ConstantValueNode(static_cast(-42))); - std::vector> args; - args.emplace_back(std::move(cond)); - args.emplace_back(std::move(t)); - args.emplace_back(std::move(f)); - std::unique_ptr node(new IfNode(std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_IfThenElse); - -// B-5: N-way switch. All conditions are 0 except the last, so evaluation -// traverses every branch (worst-case path). -void BM_Execute_Switch(benchmark::State& state) { - const int n = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector> args; - for (int i = 0; i < n; ++i) { - uint8_t cond_val = (i == n - 1) ? 1 : 0; - args.emplace_back(new ConstantValueNode(cond_val)); - args.emplace_back(new ConstantValueNode(static_cast(i))); - } - args.emplace_back(new ConstantValueNode(static_cast(-1))); // default - std::unique_ptr node(new SwitchNode(std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_Switch)->Arg(2)->Arg(8)->Arg(32); - -// B-6: IfBlock — multi-statement blocks. -// Args layout: [cond1, block1, cond2, block2, ..., else_block]. -// Each block binds a named `result` variable; after the IfBlock we -// store(ref("result")) so the branches are observably live. Without this -// sink LLVM would collapse the whole function to `ret void`. -void BM_Execute_IfBlock(benchmark::State& state) { - auto reg = MakeRegistryWithStore(); - - auto make_block = [](int32_t v) { - auto block = std::unique_ptr(new NoOPNode({}, {})); - static_cast(block.get())->AppendArgs("result", std::unique_ptr(new ConstantValueNode(v))); - return block; - }; - - std::vector> if_args; - if_args.emplace_back(new ConstantValueNode(static_cast(1))); - if_args.emplace_back(make_block(100)); - if_args.emplace_back(new ConstantValueNode(static_cast(0))); - if_args.emplace_back(make_block(200)); - if_args.emplace_back(make_block(300)); // else block - auto if_block = std::unique_ptr(new IfBlockNode(std::move(if_args))); - - // root = [ result = 0, , store(output, 0, ref("result")) ] - // `result` must be declared in the outer scope so RefNode("result") can - // resolve it after the IfBlock; this matches the pattern used in - // test/if_block_test.cc. - auto root = std::unique_ptr(new NoOPNode({}, {})); - static_cast(root.get()) - ->AppendArgs("result", std::unique_ptr(new ConstantValueNode(static_cast(0)))); - static_cast(root.get())->AppendArgs(std::move(if_block)); - static_cast(root.get())->AppendArgs(MakeStoreI32(0, std::unique_ptr(new RefNode("result")))); - - auto engine = CompileOrDie(std::move(root), reg); - ExecContext ctx(4096); - int32_t output = 0; - for (auto _ : state) { - ctx.Clear(); - auto st = engine->Execute(ctx, nullptr, static_cast(&output)); - benchmark::DoNotOptimize(output); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_IfBlock); - -// B-7: RefNode — common sub-expression reuse. -// Names a sub-expression via the NoOPNode named-form and references it -// through RefNode. The result of the multiplication is written out via -// `store(output, 0, ...)`; without that side effect LLVM's DCE would -// collapse the whole entry function to `ret void` because NoOPNode itself -// returns void. -void BM_Execute_RefNode(benchmark::State& state) { - auto reg = MakeRegistryWithStore(); - - // x = 10 + 20 - std::unique_ptr inner( - new BinaryOPNode(BinaryOPType::kAdd, std::unique_ptr(new ConstantValueNode(static_cast(10))), - std::unique_ptr(new ConstantValueNode(static_cast(20))))); - - // ref("x") * ref("x") - auto product = std::unique_ptr(new BinaryOPNode( - BinaryOPType::kMul, std::unique_ptr(new RefNode("x")), std::unique_ptr(new RefNode("x")))); - - std::vector names = {"x", ""}; - std::vector> items; - items.emplace_back(std::move(inner)); - items.emplace_back(MakeStoreI32(0, std::move(product))); - std::unique_ptr node(new NoOPNode(std::move(names), std::move(items))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - int32_t output = 0; - for (auto _ : state) { - ctx.Clear(); - auto st = engine->Execute(ctx, nullptr, static_cast(&output)); - benchmark::DoNotOptimize(output); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_RefNode); - -// B-8: Builtin function-call execute cost (abs). -void BM_Execute_FunctionCall_Builtin(benchmark::State& state) { - auto reg = MakeRegistry(); - std::unique_ptr arg(new ConstantValueNode(static_cast(-12345))); - std::vector> args; - args.emplace_back(std::move(arg)); - std::unique_ptr node(new FunctionNode("abs", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_FunctionCall_Builtin); - -// ============================================================================= -// C. List aggregation — kernel cost vs. list length -// ============================================================================= -// -// These cases share a single shape (aggregate kernel called on a constant -// int64 list) and vary only the length. Names and argument lists are fixed -// because gh-pages indexes by the full name incl. "/N". - -void BM_Execute_ListSum(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Sum", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSum)->Arg(16)->Arg(256)->Arg(4096); - -void BM_Execute_ListMax(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Max", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListMax)->Arg(16)->Arg(256)->Arg(4096); - -void BM_Execute_ListAvg(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Avg", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListAvg)->Arg(16)->Arg(256)->Arg(4096); - -// ----------------------------------------------------------------------------- -// C-extra: remaining aggregation kernels. -// Every kernel gets its own benchmark name so gh-pages can plot it -// independently. Two list lengths (256, 4096) are enough to distinguish -// O(N) kernels from O(N log N) / O(N^2) ones. -// ----------------------------------------------------------------------------- - -void BM_Execute_ListMin(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Min", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListMin)->Arg(256)->Arg(4096); - -void BM_Execute_ListMedian(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Median", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListMedian)->Arg(256)->Arg(4096); - -void BM_Execute_ListSortedMedian(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("SortedMedian", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSortedMedian)->Arg(256)->Arg(4096); - -void BM_Execute_ListCountDistinct(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("CountDistinct", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListCountDistinct)->Arg(256)->Arg(4096); - -// CountBits is only registered for U8List. -void BM_Execute_ListCountBits(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector values(len, static_cast(0xA5)); - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - std::unique_ptr node(new FunctionNode("CountBits", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListCountBits)->Arg(256)->Arg(4096); - -// GetAt(list, 0) — random access cost, should be O(1). -void BM_Execute_ListGetAt(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector values; - values.reserve(len); - for (int i = 0; i < len; ++i) { - values.push_back(i); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(static_cast(0))); - std::unique_ptr node(new FunctionNode("GetAt", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListGetAt)->Arg(256)->Arg(4096); - -// ============================================================================= -// G. List basic — shape-manipulation kernels -// ============================================================================= - -// Len is O(1); one length sample is enough. -void BM_Execute_ListLen(benchmark::State& state) { - auto reg = MakeRegistry(); - std::vector values(256, 0); - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - std::unique_ptr node(new FunctionNode("Len", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListLen); - -void BM_Execute_ListUnique(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCtxCall("Unique", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListUnique)->Arg(256)->Arg(4096); - -void BM_Execute_ListSortAsc(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCtxCall("SortAsc", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSortAsc)->Arg(256)->Arg(4096); - -void BM_Execute_ListSortDesc(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCtxCall("SortDesc", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSortDesc)->Arg(256)->Arg(4096); - -// Truncate takes (list, u32) — keep the first `keep_n` elements. -void BM_Execute_ListTruncate(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector values; - values.reserve(len); - for (int i = 0; i < len; ++i) { - values.push_back(i); - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(static_cast(len / 2))); - std::unique_ptr node(new FunctionNode("Truncate", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListTruncate)->Arg(256)->Arg(4096); - -void BM_Execute_ListCastStringList(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCtxCall("CastStringList", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListCastStringList)->Arg(256)->Arg(4096); - -void BM_Execute_ListMurmurHash3X8632(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("MurmurHash3X8632", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListMurmurHash3X8632)->Arg(256)->Arg(4096); - -// ListConcat(listA, listB, ctx). -void BM_Execute_ListConcat(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListListCtxCall("ListConcat", len), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096); - -// `in(needle, haystack_list)` — scalar-in-list membership test (not list-out). -void BM_Execute_ListIn(benchmark::State& state) { - const int len = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector values; - values.reserve(len); - for (int i = 0; i < len; ++i) { - values.push_back(i); - } - std::vector> args; - // Search for a value near the end to force worst-case linear scan. - args.emplace_back(new ConstantValueNode(static_cast(len - 1))); - args.emplace_back(new ConstantListValueNode(std::move(values))); - std::unique_ptr node(new FunctionNode("in", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListIn)->Arg(256)->Arg(4096); - -// ============================================================================= -// H. List element-wise unary (func(list, ctx) -> list) -// ============================================================================= - -#define JITFUSION_DEFINE_LIST_UNARY_BM(NAME) \ - void BM_Execute_##NAME(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListUnaryCtxCall(#NAME, len), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME)->Arg(256)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_UNARY_BM(ListExp); -JITFUSION_DEFINE_LIST_UNARY_BM(ListLog); -JITFUSION_DEFINE_LIST_UNARY_BM(ListLog2); -JITFUSION_DEFINE_LIST_UNARY_BM(ListLog10); -#undef JITFUSION_DEFINE_LIST_UNARY_BM - -// ListCeil / ListFloor / ListRound only accept float lists. -#define JITFUSION_DEFINE_LIST_UNARY_F64_BM(NAME) \ - void BM_Execute_##NAME(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListUnaryCtxCallF64(#NAME, len), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME)->Arg(256)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListCeil); -JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListFloor); -JITFUSION_DEFINE_LIST_UNARY_F64_BM(ListRound); - -#undef JITFUSION_DEFINE_LIST_UNARY_F64_BM - -// ============================================================================= -// I. List element-wise binary — two shapes -// ============================================================================= -// -// Every kernel in this family is overloaded for both: -// - `Scalar` : list OP scalar -> list (broadcast) -// - `LL` : list OP list -> list (zip) -// Both shapes are exercised so we can see whether the list-list path takes -// a different code branch (e.g. lacks vectorisation). - -#define JITFUSION_DEFINE_LIST_BINARY_BM(NAME) \ - void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, 2), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096); \ - void BM_Execute_##NAME##_LL(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListListCtxCall(#NAME, len), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME##_LL)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_BINARY_BM(ListAdd); -JITFUSION_DEFINE_LIST_BINARY_BM(ListSub); -JITFUSION_DEFINE_LIST_BINARY_BM(ListMul); -JITFUSION_DEFINE_LIST_BINARY_BM(ListDiv); -JITFUSION_DEFINE_LIST_BINARY_BM(ListMod); -#undef JITFUSION_DEFINE_LIST_BINARY_BM - -// ListMax / ListMin are only registered in the list-scalar (broadcast) form: -// there is no list-list overload in the current function registry. Exercising -// the `_LL` variant would cause Compile() to fail (no matching signature), -// which in turn aborts the whole benchmark binary via CompileOrDie(). Keep -// only the scalar shape here — if list-list versions get added later, move -// these two back into JITFUSION_DEFINE_LIST_BINARY_BM. -#define JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(NAME) \ - void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, 2), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(ListMax); -JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM(ListMin); -#undef JITFUSION_DEFINE_LIST_BINARY_SCALAR_ONLY_BM - -// Bitwise kernels are only registered for unsigned integer types. -#define JITFUSION_DEFINE_LIST_BITWISE_BM(NAME) \ - void BM_Execute_##NAME##_Scalar(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListScalarCtxCallU64(#NAME, len, 0xFFULL), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME##_Scalar)->Arg(4096); \ - void BM_Execute_##NAME##_LL(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListListCtxCallU64(#NAME, len), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME##_LL)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseAnd); -JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseOr); -JITFUSION_DEFINE_LIST_BITWISE_BM(ListBitwiseXor); - -#undef JITFUSION_DEFINE_LIST_BITWISE_BM - -// ============================================================================= -// J. List comparison / bitmap kernels -// ============================================================================= -// -// Two sub-families here: -// - `Gen*Bitmap(list, pivot, ctx)` : produce a U8List bitmap. -// - `If*(list, pivot, alt, ctx)` : pick from `list` vs `alt` per element. -// Plus two helpers that consume a bitmap: `IfByBitmap`, `FilterByBitmap`. - -#define JITFUSION_DEFINE_LIST_GENBITMAP_BM(NAME) \ - void BM_Execute_##NAME(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListScalarCtxCall(#NAME, len, len / 2), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenEqualBitmap); -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenNotEqualBitmap); -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLargeBitmap); -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLargeEqualBitmap); -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLessBitmap); -JITFUSION_DEFINE_LIST_GENBITMAP_BM(GenLessEqualBitmap); - -#undef JITFUSION_DEFINE_LIST_GENBITMAP_BM - -#define JITFUSION_DEFINE_LIST_IFSELECT_BM(NAME) \ - void BM_Execute_##NAME(benchmark::State& state) { \ - const int len = static_cast(state.range(0)); \ - auto reg = MakeRegistry(); \ - auto engine = CompileOrDie(MakeListIfSelectCall(#NAME, len), reg); \ - ExecContext ctx(4096); \ - for (auto _ : state) { \ - ctx.Clear(); \ - RetType result; \ - auto st = engine->Execute(ctx, nullptr, &result); \ - benchmark::DoNotOptimize(result); \ - if (!st.ok()) { \ - state.SkipWithError("execute failed"); \ - } \ - } \ - } \ - BENCHMARK(BM_Execute_##NAME)->Arg(4096) // NOLINT - -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfEqual); -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfNotEqual); -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLarge); -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLargeEqual); -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLess); -JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLessEqual); - -#undef JITFUSION_DEFINE_LIST_IFSELECT_BM - -// IfByBitmap(packed_bitmap, value_list, alt_scalar, ctx). -// For each element i: packed_bitmap bit i set ? value_list[i] : alt_scalar. -// `packed_bitmap` is a U8List of ceil(len/8) bytes, LSB = first element. -void BM_Execute_IfByBitmap(benchmark::State& state) { - const int len = static_cast(state.range(0)); - const int bitmap_bytes = (len + 7) / 8; - auto reg = MakeRegistry(); - std::vector bitmap(bitmap_bytes, static_cast(0x55)); // every other bit set - std::vector values(len); - for (int i = 0; i < len; ++i) { - values[i] = i; - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(bitmap))); - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); - std::unique_ptr node(new FunctionNode("IfByBitmap", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_IfByBitmap)->Arg(4096); - -// FilterByBitmap(value_list, packed_bitmap, popcount, ctx). -// -// NOTE: unlike IfByBitmap (whose U8List is a per-element 0/1 array), here the -// bitmap is a *packed* bitmap — each byte encodes 8 elements (LSB = first -// element). So its length must be exactly ceil(values.size() / 8), and -// `popcnt` is the number of 1-bits across all bytes. Using a per-element -// bitmap triggers "bitmap len is not corresponding to list len" at runtime. -// Using 0x55 (0b01010101) gives 4 ones per byte → every other element kept. -void BM_Execute_FilterByBitmap(benchmark::State& state) { - const int len = static_cast(state.range(0)); - const int bitmap_bytes = (len + 7) / 8; - auto reg = MakeRegistry(); - std::vector values(len); - std::vector bitmap(bitmap_bytes, static_cast(0x55)); - uint32_t popcnt = 0; - for (int i = 0; i < len; ++i) { - values[i] = i; - } - // Count set bits per byte. This runs once during benchmark setup, not in - // the timed loop, so a plain portable loop is fine — no need for - // __builtin_popcount / std::popcount. - for (int b = 0; b < bitmap_bytes; ++b) { - uint8_t byte = bitmap[b]; - while (byte != 0) { - popcnt += static_cast(byte & 1U); - byte = static_cast(byte >> 1); - } - } - std::vector> args; - args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new ConstantListValueNode(std::move(bitmap))); - args.emplace_back(new ConstantValueNode(popcnt)); - args.emplace_back(new jitfusion::ExecContextNode()); - std::unique_ptr node(new FunctionNode("FilterByBitmap", std::move(args))); - - auto engine = CompileOrDie(std::move(node), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_FilterByBitmap)->Arg(4096); - -// ============================================================================= -// D. ExecContext reuse — arena allocator cost -// ============================================================================= -// -// Same AST, same engine, two call patterns: -// - Reuse: one ExecContext is shared across iterations, Clear()'d each time -// → arena memory from the first iteration is kept and reused. -// - Fresh: a new ExecContext is constructed every iteration -// → arena allocator starts from scratch, paying first-chunk malloc cost. -// The gap is the payoff of the ExecContext& Execute overload on hot paths. - -void BM_Execute_ArenaReuse(benchmark::State& state) { - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeLinearAddChain(8), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ArenaReuse); - -void BM_Execute_ArenaFresh(benchmark::State& state) { - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeLinearAddChain(8), reg); - for (auto _ : state) { - ExecContext ctx(4096); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ArenaFresh); - -// Same pair, but with a list aggregation that forces real arena usage -// (list materialisation + kernel scratch space), so the reuse / fresh gap -// is more visible than in the const-fold case above. -void BM_Execute_ListSum_ArenaReuse(benchmark::State& state) { - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Sum", 256), reg); - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSum_ArenaReuse); - -void BM_Execute_ListSum_ArenaFresh(benchmark::State& state) { - auto reg = MakeRegistry(); - auto engine = CompileOrDie(MakeListUnaryCall("Sum", 256), reg); - for (auto _ : state) { - ExecContext ctx(4096); - RetType result; - auto st = engine->Execute(ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute failed"); - } - } -} -BENCHMARK(BM_Execute_ListSum_ArenaFresh); - -// ============================================================================= -// E. Batch execute -// ============================================================================= -// -// BatchCompile N ASTs once, then measure only the per-iteration execute -// cost. Two access patterns: -// - ExecuteAll: hand the vector back in one call. -// - ExecuteAtLoop: call ExecuteAt(i) in a loop on the benchmark side. -// The two should be close; a large gap would point at per-call overhead in -// the wrapper layer. - -void BM_BatchExecute_All(benchmark::State& state) { - const int n = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector> nodes; - nodes.reserve(n); - for (int i = 0; i < n; ++i) { - nodes.emplace_back(MakeLinearAddChain(8)); - } - ExecEngine engine; - auto cs = engine.BatchCompile(nodes, reg); - if (!cs.ok()) { - state.SkipWithError("batch compile failed"); - return; - } - ExecContext ctx(4096); - std::vector results; - for (auto _ : state) { - ctx.Clear(); - results.clear(); - auto st = engine.ExecuteAll(ctx, nullptr, &results); - benchmark::DoNotOptimize(results); - if (!st.ok()) { - state.SkipWithError("execute all failed"); - } - } -} -BENCHMARK(BM_BatchExecute_All)->Arg(2)->Arg(8)->Arg(32); - -void BM_BatchExecute_AtLoop(benchmark::State& state) { - const int n = static_cast(state.range(0)); - auto reg = MakeRegistry(); - std::vector> nodes; - nodes.reserve(n); - for (int i = 0; i < n; ++i) { - nodes.emplace_back(MakeLinearAddChain(8)); - } - ExecEngine engine; - auto cs = engine.BatchCompile(nodes, reg); - if (!cs.ok()) { - state.SkipWithError("batch compile failed"); - return; - } - ExecContext ctx(4096); - for (auto _ : state) { - ctx.Clear(); - for (int i = 0; i < n; ++i) { - RetType result; - auto st = engine.ExecuteAt(static_cast(i), ctx, nullptr, &result); - benchmark::DoNotOptimize(result); - if (!st.ok()) { - state.SkipWithError("execute_at failed"); - break; - } - } - } -} -BENCHMARK(BM_BatchExecute_AtLoop)->Arg(2)->Arg(8)->Arg(32); - -// ============================================================================= -// F. Native C++ baselines -// ============================================================================= -// -// Hand-written C++ counterparts of selected B/C cases. They give a concrete -// "zero-overhead" reference point so the engine's numbers can be read as -// "JIT overhead over optimal native". -// -// NOTE: gh-pages plots the raw times, so do NOT rename these — the pairing -// with the engine variants (e.g. BM_Execute_Arith/0 vs BM_Native_Arith_i64) -// is implicit in the name. If you add a new engine variant, add its native -// twin right next to it. - -void BM_Native_Arith_i64(benchmark::State& state) { - int64_t a = 1234567; - int64_t b = 7654321; - for (auto _ : state) { - benchmark::DoNotOptimize(a); - benchmark::DoNotOptimize(b); - int64_t r = a * b; - benchmark::DoNotOptimize(r); - } -} -BENCHMARK(BM_Native_Arith_i64); - -void BM_Native_Arith_f64(benchmark::State& state) { - double a = 1.2345; - double b = 6.789; - for (auto _ : state) { - benchmark::DoNotOptimize(a); - benchmark::DoNotOptimize(b); - double r = a * b; - benchmark::DoNotOptimize(r); - } -} -BENCHMARK(BM_Native_Arith_f64); - -void BM_Native_ListSum_i64(benchmark::State& state) { - const int len = static_cast(state.range(0)); - std::vector values; - values.reserve(len); - for (int i = 0; i < len; ++i) { - values.push_back(i); - } - for (auto _ : state) { - benchmark::DoNotOptimize(values.data()); - int64_t sum = std::accumulate(values.begin(), values.end(), int64_t{0}); - benchmark::DoNotOptimize(sum); - } -} -BENCHMARK(BM_Native_ListSum_i64)->Arg(16)->Arg(256)->Arg(4096); - -} // namespace - -BENCHMARK_MAIN(); diff --git a/build.log b/build.log new file mode 100644 index 0000000..7ec055d --- /dev/null +++ b/build.log @@ -0,0 +1,14783 @@ +Computing main repo mapping: +Loading: +Loading: 0 packages loaded +Analyzing: target //:jitfusion_test (1 packages loaded, 0 targets configured) +Analyzing: target //:jitfusion_test (1 packages loaded, 0 targets configured) + +INFO: Analyzed target //:jitfusion_test (89 packages loaded, 7138 targets configured). +[10 / 64] Compiling test/binary_op_test.cc; 1s darwin-sandbox ... (12 actions running) +[10 / 64] Compiling test/binary_op_test.cc; 6s darwin-sandbox ... (13 actions, 12 running) +[11 / 64] Compiling test/binary_op_test.cc; 7s darwin-sandbox ... (12 actions, 11 running) +[11 / 64] Compiling test/binary_op_test.cc; 9s darwin-sandbox ... (13 actions, 12 running) +[12 / 64] Compiling test/binary_op_test.cc; 10s darwin-sandbox ... (13 actions, 12 running) +[19 / 64] Compiling test/function_test.cc; 11s darwin-sandbox ... (13 actions, 12 running) +[22 / 64] Compiling test/list_basic_test.cc; 4s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/arena.cc: +src/arena.cc:88:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 88 | free(buf); + | ^ +src/arena.cc:126:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 126 | for (auto& chunk : chunks_) { + | ^ +src/arena.cc:126:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/arena.cc:88:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 88 | free(buf); + | ^ +src/arena.cc:126:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 126 | for (auto& chunk : chunks_) { + | ^ +src/arena.cc:126:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[24 / 64] Compiling test/list_cast_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) +[25 / 64] Compiling test/list_bitwise_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/codegen/binary_op_codegen.cc: +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/binary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: +In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: +In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 2374 | for (const auto &B : Bundles) + | ^ +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +INFO: From Compiling src/codegen/codegen.cc: +In file included from src/codegen/codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[33 / 64] Compiling test/list_group_test.cc; 4s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/codegen/const_list_value_codegen.cc: +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2138:9: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 2138 | if (!value_comp()(__root->__value_, __v)) { + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1292: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:736:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 736 | return __index == __variant_npos<__index_t> ? variant_npos : __index; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1510 | if (__rhs.valueless_by_exception()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 2137 | while (__root != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 21 | for (std::size_t idx = 0; idx < list.size(); ++idx) { + | ^ +src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1854: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 30 | for (; __first2 != __last2; ++__first1, (void)++__first2) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:620: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:124:14: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 124 | return __builtin_memcmp(__lhs, __rhs, __count); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1854: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 30 | for (; __first2 != __last2; ++__first1, (void)++__first2) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1680:11: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1680 | if (value_comp()(__v, __nd->__value_)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:0:0 + 1773 | __tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1773 | __tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1679 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1004 | } else + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 548 | while (__first1 != __last1) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 517 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/const_list_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 284 | while (__x != __root && !__x->__parent_unsafe()->__is_black_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[35 / 64] Compiling test/list_group_test.cc; 5s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/codegen/const_value_codegen.cc: +In file included from src/codegen/const_value_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[36 / 64] Compiling test/list_group_test.cc; 6s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/codegen/entry_argument_codegen.cc: +In file included from src/codegen/entry_argument_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/entry_argument_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/entry_argument_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/entry_argument_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/codegen/function_codegen.cc: +In file included from src/codegen/function_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:308: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:265:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 265 | return __builtin_operator_new(__args...); + | ^ +In file included from src/codegen/function_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/concepts.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/format_parse_context.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:645:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 645 | __builtin_memcpy(const_cast<__remove_const_t<_Tp>*>(__result), __first, sizeof(_Tp) * (__last - __first)); + | ^ +src/codegen/function_codegen.cc:24:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 24 | for (const auto& args : args_list) { + | ^ +src/codegen/function_codegen.cc:24:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/codegen/function_codegen.cc:24:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/function_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/function_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/function_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: +In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: +In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 2374 | for (const auto &B : Bundles) + | ^ +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +INFO: From Compiling src/codegen/if_block_codegen.cc: +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 106 | for (const auto &[name, val] : info.modified) { + | ^ +src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1077 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1076 | __u.size() = 0; + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:547: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__node_handle:65: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 633 | while (__iter != __last) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1077 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1076 | __u.size() = 0; + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:547: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__node_handle:65: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 633 | while (__iter != __last) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:27: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:27: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/codegen/if_block_codegen.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/codegen/no_op_codegen.cc: +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1077 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1076 | __u.size() = 0; + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 633 | while (__iter != __last) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/codegen/no_op_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/codegen/if_codegen.cc: +In file included from src/codegen/if_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/if_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[44 / 64] Compiling src/codegen/ref_node_codegen.cc; 3s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/diagnostic.cc: +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:265:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 265 | return __builtin_operator_new(__args...); + | ^ +src/diagnostic.cc:32:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 32 | for (size_t i = 0; i < text.size(); ++i) { + | ^ +src/diagnostic.cc:32:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:32:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:32:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:12: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1002:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1002 | __r_.first() = __str.__r_.first(); + | ^ +src/diagnostic.cc:85:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 85 | for (int ln = start_line; ln <= end_line && ln <= total_lines; ++ln) { + | ^ +src/diagnostic.cc:85:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:85:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:12: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +src/diagnostic.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 106 | for (const auto& note : notes_) { + | ^ +src/diagnostic.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:106:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:12: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +src/diagnostic.cc:109:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 109 | for (const auto& hint : hints_) { + | ^ +src/diagnostic.cc:109:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:109:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:12: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +src/diagnostic.cc:61:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 61 | for (const auto& note : notes_) { + | ^ +src/diagnostic.cc:61:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:61:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/diagnostic.cc:7: +In file included from include/diagnostic.h:12: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +src/diagnostic.cc:64:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 64 | for (const auto& hint : hints_) { + | ^ +src/diagnostic.cc:64:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/diagnostic.cc:64:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/codegen/ref_node_codegen.cc: +In file included from src/codegen/ref_node_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1380:90: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1380 | _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); } + | ^ +In file included from src/codegen/ref_node_codegen.cc:7: +In file included from src/codegen/codegen.h:12: +src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 37 | for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { + | ^ +src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/scope_stack.h:37:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/ref_node_codegen.cc:7: +In file included from src/codegen/codegen.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ + +INFO: From Compiling src/function/murmurhash3.cc: +src/function/murmurhash3.cc:95:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 95 | for (int i = -nblocks; i; i++) { + | ^ +src/function/murmurhash3.cc:95:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/murmurhash3.cc:158:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 158 | for (int i = -nblocks; i; i++) { + | ^ +src/function/murmurhash3.cc:158:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/murmurhash3.cc:313:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 313 | for (int i = 0; i < nblocks; i++) { + | ^ +src/function/murmurhash3.cc:313:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/codegen/switch_codegen.cc: +In file included from src/codegen/switch_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/switch_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:34: +external/llvm/llvm/include/llvm/IR/Instructions.h:2639:7: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 2639 | growOperands(); // Get more space! + | ^ +external/llvm/llvm/include/llvm/IR/Instructions.h:2638:29: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 2638 | if (getNumOperands() == ReservedSpace) + | ^ +src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 71 | for (const auto &[val, block] : incoming_values) { + | ^ +src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/switch_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/codegen/switch_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/exec_node.cc: +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 226 | } else if (__count > 0) { + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 931 | __r_.first() = __rep(); + | ^ +src/exec_node.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 106 | for (const auto& child : args_) { + | ^ +src/exec_node.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:106:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 15 | auto cloned = CloneImpl(); + | ^ +In file included from src/exec_node.cc:7: +include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } + | ^ +src/exec_node.cc:119:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (const auto& arg : args_) { + | ^ +src/exec_node.cc:119:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:119:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:928:9: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 928 | if (__size > max_size()) + | ^ +src/exec_node.cc:127:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 127 | for (size_t i = 0; i < args_.size(); ++i) { + | ^ +src/exec_node.cc:127:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:127:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:127:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 15 | auto cloned = CloneImpl(); + | ^ +In file included from src/exec_node.cc:7: +include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } + | ^ +src/exec_node.cc:150:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 150 | for (const auto& arg : args_) { + | ^ +src/exec_node.cc:150:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:150:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 226 | } else if (__count > 0) { + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 931 | __r_.first() = __rep(); + | ^ +src/exec_node.cc:158:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 158 | for (const auto& child : args_) { + | ^ +src/exec_node.cc:158:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:158:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 15 | auto cloned = CloneImpl(); + | ^ +In file included from src/exec_node.cc:7: +include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } + | ^ +src/exec_node.cc:171:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 171 | for (const auto& arg : args_) { + | ^ +src/exec_node.cc:171:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 226 | } else if (__count > 0) { + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 931 | __r_.first() = __rep(); + | ^ +src/exec_node.cc:179:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 179 | for (const auto& child : args_) { + | ^ +src/exec_node.cc:179:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:179:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 15 | auto cloned = CloneImpl(); + | ^ +In file included from src/exec_node.cc:7: +include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } + | ^ +src/exec_node.cc:192:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 192 | for (const auto& arg : args_) { + | ^ +src/exec_node.cc:192:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:192:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 226 | } else if (__count > 0) { + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 931 | __r_.first() = __rep(); + | ^ +src/exec_node.cc:200:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 200 | for (const auto& child : args_) { + | ^ +src/exec_node.cc:200:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:200:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 15 | auto cloned = CloneImpl(); + | ^ +In file included from src/exec_node.cc:7: +include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } + | ^ +src/exec_node.cc:212:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 212 | for (const auto& arg : args_) { + | ^ +src/exec_node.cc:212:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:212:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | for (const auto& value : value_list) { + | ^ +src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1004 | } else + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 548 | while (__first1 != __last1) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_node.cc:7: +In file included from include/exec_node.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 517 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[49 / 64] Compiling test/no_op_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) +INFO: From Compiling src/codegen/unary_op_codegen.cc: +In file included from src/codegen/unary_op_codegen.cc:7: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +[52 / 64] Compiling src/exec_engine.cc; 2s darwin-sandbox ... (11 actions running) +INFO: From Compiling src/function/string_function_init.cc: +In file included from src/function/string_function_init.cc:10: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:226: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 380 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/string_function_init.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/function/math_function_init.cc: +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1004 | } else + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1002:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1002 | __r_.first() = __str.__r_.first(); + | ^ +src/function/math_function_init.cc:431:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 431 | for (auto args_type : kTypeVec) { + | ^ +src/function/math_function_init.cc:431:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/math_function_init.cc:431:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: +In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: +In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 2374 | for (const auto &B : Bundles) + | ^ +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1004 | } else + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 548 | while (__first1 != __last1) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/function/math_function_init.cc:8: +In file included from src/codegen/codegen.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 517 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/function_registry.cc: +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { + | ^ +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 81 | for (const auto& param_type : param_types_) { + | ^ +src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:13: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:534: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/bind.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/tuple:1411: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/exception:81: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__exception/exception_ptr.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/function_registry.cc:92:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 92 | for (std::size_t i = 0; i < param_types_.size(); i++) { + | ^ +src/function_registry.cc:92:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:180:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 180 | auto* func = m->getFunction(sign.ToString()); + | ^ +src/function_registry.cc:176:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 176 | for (const auto& [sign, fc] : signature2funcstruct_) { + | ^ +src/function_registry.cc:176:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:176:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:176:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:200:37: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 200 | symbols.try_emplace(mangle(sign.ToString()), function_a_address, llvm::JITSymbolFlags::Exported); + | ^ +src/function_registry.cc:195:31: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 195 | for (const auto& [sign, fc] : signature2funcstruct_) { + | ^ +src/function_registry.cc:195:31: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:195:31: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:195:31: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:174:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 174 | ++S->getValue(); + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:900:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 900 | return Buckets; + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 477 | for (size_t i = 0; i < getNumBuckets(); ++i) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 181 | } + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 181 | } + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 181 | } + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 671 | while (true) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 181 | } + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 81 | for (const auto& param_type : param_types_) { + | ^ +src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { + | ^ +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 81 | for (const auto& param_type : param_types_) { + | ^ +src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { + | ^ +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:24: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/builtin_new_allocator.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 81 | for (const auto& param_type : param_types_) { + | ^ +src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { + | ^ +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function_registry.cc:7: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 671 | while (true) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 423 | for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B) + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 671 | while (true) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/function/list_aggregation.cc: +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] + 26 | for (std::size_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1132 | for (; __first != __last; ++__first) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_aggregation.cc:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_aggregation.cc:97:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 97 | for (; i < batch_end; i += 8) { + | ^ +src/function/list_aggregation.cc:103:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] + 103 | for (; i < a.len; i++) { + | ^ +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] + 38 | for (std::size_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 30 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 191 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 205 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 161 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 154 | while (__comp(*__i, *__m)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 124 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 118 | while (!__comp(*__first, *__i)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 35 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 40 | return __lhs < __rhs; + | ^ +In file included from src/function/list_aggregation.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 37 | while (++__i != __last) + | ^ +[56 / 64] Compiling src/exec_engine.cc; 4s darwin-sandbox ... (7 actions running) + +INFO: From Compiling src/function/list_group.cc: +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 39 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1268 | return __table_.__emplace_unique_key_args( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:58:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 58 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:58:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:58:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_group.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +src/function/list_group.cc:74:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 74 | for (uint32_t i = 0; i < group_index.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 94 | result.data[filled++] = keys.data[i]; + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:95:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 95 | } + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 92 | for (uint32_t i = 0; i < keys.len; ++i) { + | ^ +src/function/list_group.cc:92:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:16: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: +In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) + | ^ +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:16: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_group.cc:16: +In file included from src/codegen/codegen.h:11: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: +In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: +In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 2374 | for (const auto &B : Bundles) + | ^ +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop +Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop +Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop +Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop +Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop +Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 115 | result.data[group_index.data[i]] += values.data[i]; + | ^ +src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 114 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 134 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + | ^ +src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 154 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:175:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 175 | result.data[gid] += values.data[i]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +src/function/list_group.cc:175:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 175 | result.data[gid] += values.data[i]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ +In file included from src/function/list_group.cc:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 1437 | return this->__begin_[__n]; + | ^ +src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 173 | for (uint32_t i = 0; i < values.len; ++i) { + | ^ +src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 178 | for (uint32_t g = 0; g < distinct; ++g) { + | ^ + +INFO: From Compiling src/validator.cc: +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/validator.cc:253:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 253 | JF_RETURN_NOT_OK(arg->Accept(this)); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/validator.cc:252:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 252 | for (const auto& arg : function_node.GetArgs()) { + | ^ +src/validator.cc:252:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/validator.cc:252:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/validator.cc:304:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 304 | JF_RETURN_NOT_OK(arg->Accept(this)); + | ^ +src/validator.cc:303:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 303 | for (const auto& arg : if_node.GetArgs()) { + | ^ +src/validator.cc:303:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/validator.cc:303:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/validator.cc:303:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/validator.cc:337:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 337 | JF_RETURN_NOT_OK(arg->Accept(this)); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/validator.cc:336:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 336 | for (const auto& arg : switch_node.GetArgs()) { + | ^ +src/validator.cc:336:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/validator.cc:336:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/validator.cc:347:41: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 347 | if (i + 1 != size && i % 2 == 0 && !TypeHelper::IsNumericType(switch_node.GetArgs()[i]->GetReturnType())) { + | ^ +src/validator.cc:346:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 346 | for (std::size_t i = 0; i < size; i++) { + | ^ +src/validator.cc:346:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/validator.cc:346:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/validator.cc:346:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1379 | _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1380:90: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1380 | _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); } + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:12: +src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 37 | for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { + | ^ +src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/scope_stack.h:37:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1077 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1076 | __u.size() = 0; + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 633 | while (__iter != __last) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1775 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1757:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1757 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1754 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1757:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1757 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1754 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/validator.cc:7: +In file included from src/validator.h:9: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/validator.cc:7: +In file included from src/validator.h:10: +In file included from include/exec_node.h:13: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/exec_engine.cc: +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1553 | pointer __end = this->__end_; + | ^ +src/exec_engine.cc:404:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 404 | EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) + | ^ +src/exec_engine.cc:404:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:404:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1361 | return append(__s); + | ^ +In file included from src/exec_engine.cc:7: +include/exec_engine.h:46:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 46 | for (size_t i = 0; i < errors.size(); ++i) { + | ^ +include/exec_engine.h:46:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +include/exec_engine.h:46:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1553 | pointer __end = this->__end_; + | ^ +src/exec_engine.cc:412:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 412 | EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) + | ^ +src/exec_engine.cc:412:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:412:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:448:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 448 | JF_RETURN_NOT_OK(validator.Validate(exec_node.get())); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_engine.cc:447:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 447 | for (const auto& exec_node : exec_nodes) { + | ^ +src/exec_engine.cc:447:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:447:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:462:50: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 462 | std::string func_name = kEntryFunctionName + std::to_string(i); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1028:9: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 1028 | : __r_([](basic_string& __s) -> decltype(__s.__r_)&& { + | ^ +src/exec_engine.cc:461:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 461 | for (size_t i = 0; i < exec_nodes.size(); ++i) { + | ^ +src/exec_engine.cc:461:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:461:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:176:36: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 176 | return lookupLinkerMangled(JD, mangle(UnmangledName)); + | ^ +src/exec_engine.cc:481:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 481 | for (size_t i = 0; i < func_names.size(); ++i) { + | ^ +src/exec_engine.cc:481:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:481:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:481:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1553 | pointer __end = this->__end_; + | ^ +src/exec_engine.cc:502:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 502 | EXPAND_SWITCH_TYPE(func_ptr, ret_type) + | ^ +src/exec_engine.cc:502:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:502:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1553 | pointer __end = this->__end_; + | ^ +src/exec_engine.cc:515:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 515 | EXPAND_SWITCH_TYPE(func_ptr, ret_type) + | ^ +src/exec_engine.cc:515:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:515:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:989: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:508:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 508 | return __at(__fmatrix, __vs.index()...)(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 787 | _LIBCPP_VARIANT_DESTRUCTOR( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:553:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 553 | Status st = ExecuteAt(i, entry_arguments, &(*results)[i]); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_engine.cc:552:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 552 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { + | ^ +src/exec_engine.cc:552:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:552:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:989: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:508:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 508 | return __at(__fmatrix, __vs.index()...)(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 787 | _LIBCPP_VARIANT_DESTRUCTOR( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:570:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 570 | Status st = ExecuteAt(i, exec_ctx, entry_arguments, &(*results)[i]); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_engine.cc:569:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 569 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { + | ^ +src/exec_engine.cc:569:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:569:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:586:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 586 | Status st = ExecuteAt(i, entry_arguments, results); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_engine.cc:585:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 585 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { + | ^ +src/exec_engine.cc:585:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:585:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:602:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 602 | Status st = ExecuteAt(i, exec_ctx, entry_arguments, results); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +src/exec_engine.cc:601:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 601 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { + | ^ +src/exec_engine.cc:601:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:601:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:16: +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:28: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) + | ^ +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) + | ^ +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:28: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) + | ^ +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) + | ^ +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) + | ^ +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 274 | __builtin_operator_delete(__args...); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:11: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1211 | if (__is_long()) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1132:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 1132 | for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1132:3: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:348: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__split_buffer:258:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 258 | for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__split_buffer:258:3: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 80 | delete __ptr; + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { + | ^ +external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:389:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 389 | __f.__f_->__clone(__f_); + | ^ +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 298 | for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void)++__ifirst) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 447 | void SmallVectorTemplateBase::grow(size_t MinSize) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 447 | void SmallVectorTemplateBase::grow(size_t MinSize) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/exec_engine.cc:165:15: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 165 | if (!called_func->hasFnAttribute(kCommutative)) { + | ^ +src/exec_engine.cc:159:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 159 | for (auto& i : bb) { + | ^ +src/exec_engine.cc:159:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:159:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/exec_engine.cc:159:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 292 | __ptr_.second()(__tmp); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 291 | if (__tmp) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:14: +In file included from include/arena.h:12: +In file included from include/status.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 401 | } + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 106 | class PassBuilder { + | ^ +external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 +In file included from src/exec_engine.cc:7: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:14: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: +In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: +In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: +In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 353 | while (S != E) { + | ^ +external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Compiling src/function/list_basic.cc: +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 55 | for (std::size_t i = 0; i < b.len; ++i) { + | ^ +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:41:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 41 | for (std::size_t i = 0; i < b.len; ++i) { + | ^ +src/function/list_basic.cc:41:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:48:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 48 | for (std::size_t i = 0; i < b.len; ++i) { + | ^ +src/function/list_basic.cc:48:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:66:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 66 | for (std::size_t i = 0; i < b.len; ++i) { + | ^ +src/function/list_basic.cc:66:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:66:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:66:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:66:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:14: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 675 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 669 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 648 | while (__first < __last && !__comp(*--__last, __pivot)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 652 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 639 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 734 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 728 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 719 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 705 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 712 | while (++__first < __last && !__comp(__pivot, *__first)) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 329 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 328 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 299 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 298 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 382 | *__j = _Ops::__iter_move(__k); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 381 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 61 | *__start = _Ops::__iter_move(__child_i); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 59 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 443 | return __x > __y; + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 45 | for (; __i != __last; ++__i) { + | ^ +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 44 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 94 | while (true) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:14: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:14: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:19: +In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:34: +external/llvm/llvm/include/llvm/IR/Instructions.h:1046:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 1046 | for (Value *Index : IdxList) + | ^ +external/llvm/llvm/include/llvm/IR/Instructions.h:1046:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:14: +In file included from include/exec_engine.h:16: +In file included from include/function_registry.h:19: +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 246 | I->setMetadata(KV.first, KV.second); + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 245 | for (const auto &KV : MetadataToCopy) + | ^ +external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 68 | return {__tx::__convert(__first, __value), errc(0)}; + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 68 | return {__tx::__convert(__first, __value), errc(0)}; + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 68 | return {__tx::__convert(__first, __value), errc(0)}; + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 57 | return __itoa::__base_10_u32(__p, __v); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:123:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 123 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:121:16: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 121 | __buffer = __itoa::__base_10_u32(__buffer, static_cast(__value / 10000000000)); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:123:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 123 | } + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:121:16: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 121 | __buffer = __itoa::__base_10_u32(__buffer, static_cast(__value / 10000000000)); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:153:22: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), a.data[i]); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:153:22: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), a.data[i]); + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 152 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 134 | return std::__subject_seq_combinator( + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:48:3: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 48 | switch (__r.ec) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 134 | return std::__subject_seq_combinator( + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 134 | return std::__subject_seq_combinator( + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:48:3: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 48 | switch (__r.ec) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 134 | return std::__subject_seq_combinator( + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:225:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 225 | return std::__from_chars_atoi(__first, __last, __value); + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 2) [-Rpass=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:225:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 225 | return std::__from_chars_atoi(__first, __last, __value); + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 171 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 101 | for (; __firstit != __lastit; ++__firstit) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 165 | do { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] + 180 | for (; __first1 < __last1; ++__first1, ++__first2) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:8: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] + 119 | for (; __r.ptr != __last; ++__r.ptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 139 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 190 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] + 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); + | ^ +src/function/list_basic.cc:206:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 206 | for (uint32_t i = 0; i < a.len; ++i) { + | ^ +src/function/list_basic.cc:206:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:206:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +src/function/list_basic.cc:206:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1136 | while (__np != nullptr) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +In file included from src/function/list_basic.cc:7: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 451 | return __ptr_.first()[__i]; + | ^ +In file included from src/function/list_basic.cc:13: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 1709 | for (size_type __i = 0; __i < __nbc; ++__i) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 1514 | for (__nd = __nd->__next_; + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 84 | operator()(const void* __key, _Size __len) const { + | ^ +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 108 | do { + | ^ +[61 / 64] Compiling src/function/list_arithmetic.cc; 5s darwin-sandbox ... (2 actions running) + +INFO: From Compiling src/function/list_arithmetic.cc: +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 31 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 77 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 105 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 123 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 151 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 169 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:169:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:197:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 197 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 215 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 243 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 261 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 289 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 307 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 335 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 353 | for (uint32_t i = 0; i < a.len; i++) { + | ^ +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 381 | for (std::size_t i = vec_size; i < result.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 408 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 435 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 462 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:9: +In file included from include/exec_engine.h:10: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: +In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: +/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 40 | *__result = *__first; + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 489 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:511:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 511 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:516:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 516 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:511:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 511 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:516:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 516 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:538:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 538 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:543:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 543 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:538:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 538 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:543:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 543 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:565:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 565 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:570:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 570 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:565:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 565 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:570:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 570 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 598 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +In file included from src/function/list_arithmetic.cc:16: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { + | ^ +src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] + 626 | for (std::size_t i = vec_size; i < a.len; ++i) { + | ^ +[62 / 64] Compiling src/function/list_comparison.cc; 6s darwin-sandbox + +INFO: From Compiling src/function/list_comparison.cc: +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 31 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 45 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 59 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 73 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 87 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] + 101 | for (std::size_t i = 0; i < a.len; i++) { + | ^ +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 122 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 129 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 145 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 170 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 177 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 193 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 529 | return vld1q_u8((uint8_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 541 | return vld1q_u16((uint16_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 551 | return vld1q_u32((uint32_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 561 | return vld1q_u64((uint64_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 535 | return vld1q_s8((int8_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 546 | return vld1q_s16((int16_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 556 | return vld1q_s32((int32_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 566 | return vld1q_s64((int64_t*)src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: +/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 572 | return vld1q_f32(src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 222 | for (; i < loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 229 | for (int j = 0; i + j < result.len; j++) { + | ^ +src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +In file included from src/function/list_comparison.cc:15: +In file included from /usr/local/include/xsimd/xsimd.hpp:62: +In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: +In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: +/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] + 153 | return vld1q_f64(src); + | ^ +src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 245 | for (std::size_t j = vec_size; j < result.len; ++j) { + | ^ +src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 268 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 291 | for (int j = 0; i + j < a.len; j++) { + | ^ +src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 328 | for (; i < vec_loop_len; i += 8) { + | ^ +src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] + 351 | for (int j = 0; i + j < len; j++) { + | ^ +src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] +src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] + 408 | result.data[cur++] = (a.data[(i * 8) + idx]); + | ^ +src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] + 401 | for (std::size_t i = 0; i < full_bytes; i++) { + | ^ +src/function/list_comparison.cc:373:38: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] + 373 | for (int mask = 0; mask < 256; mask++) { + | ^ +src/function/list_comparison.cc:381:37: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 381 | filter_index_table[mask][idx] = -1; + | ^ +src/function/list_comparison.cc:373:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] + 373 | for (int mask = 0; mask < 256; mask++) { + | ^ +src/function/list_comparison.cc:373:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] +INFO: From Linking jitfusion_test: +ld64.lld: warning: /usr/local/lib/libgtest.a(gtest-all.cc.o) has version 11.3.0, which is newer than target minimum of 11.0.0 +ld64.lld: warning: /usr/local/lib/libgtest_main.a(gtest_main.cc.o) has version 11.3.0, which is newer than target minimum of 11.0.0 +ld64.lld: warning: /opt/homebrew/Cellar/llvm/19.1.7/lib/libLLVM-19.dylib has version 14.0.0, which is newer than target minimum of 11.0.0 +INFO: Found 1 target... +Target //:jitfusion_test up-to-date: + bazel-bin/jitfusion_test +INFO: Elapsed time: 25.884s, Critical Path: 12.13s +INFO: 64 processes: 10 internal, 54 darwin-sandbox. +INFO: Build completed successfully, 64 total actions diff --git a/doc/function.md b/doc/function.md index 831334f..7a007e1 100644 --- a/doc/function.md +++ b/doc/function.md @@ -446,6 +446,97 @@ Calculate the median of a pre-sorted list. For even-length lists, returns the av f64 SortedMedian(f32list) f64 SortedMedian(f64list) +## GroupIndex +Assign each element in `keys` a dense group id in first-appearance order, starting from 0. Duplicate keys get the same id, so the resulting `u32list` has the same length as `keys` and is the shared input of every other `Group*` function below. + + u32list GroupIndex(u8list keys, ptr exec_ctx) + u32list GroupIndex(i8list keys, ptr exec_ctx) + u32list GroupIndex(u16list keys, ptr exec_ctx) + u32list GroupIndex(i16list keys, ptr exec_ctx) + u32list GroupIndex(u32list keys, ptr exec_ctx) + u32list GroupIndex(i32list keys, ptr exec_ctx) + u32list GroupIndex(u64list keys, ptr exec_ctx) + u32list GroupIndex(i64list keys, ptr exec_ctx) + u32list GroupIndex(f32list keys, ptr exec_ctx) + u32list GroupIndex(f64list keys, ptr exec_ctx) + u32list GroupIndex(stringlist keys, ptr exec_ctx) + +## GroupCount +Return the number of distinct groups encoded in a `group_index` produced by `GroupIndex`. Returns 0 for empty input. + + u32 GroupCount(u32list group_index) + +## GroupKeys +Return the distinct keys in first-appearance order, one per group. The output length equals the number of distinct groups. `keys` and `group_index` must have the same length; `group_index` is typically the result of `GroupIndex(keys, exec_ctx)`. + + u8list GroupKeys(u8list keys, u32list group_index, ptr exec_ctx) + i8list GroupKeys(i8list keys, u32list group_index, ptr exec_ctx) + u16list GroupKeys(u16list keys, u32list group_index, ptr exec_ctx) + i16list GroupKeys(i16list keys, u32list group_index, ptr exec_ctx) + u32list GroupKeys(u32list keys, u32list group_index, ptr exec_ctx) + i32list GroupKeys(i32list keys, u32list group_index, ptr exec_ctx) + u64list GroupKeys(u64list keys, u32list group_index, ptr exec_ctx) + i64list GroupKeys(i64list keys, u32list group_index, ptr exec_ctx) + f32list GroupKeys(f32list keys, u32list group_index, ptr exec_ctx) + f64list GroupKeys(f64list keys, u32list group_index, ptr exec_ctx) + stringlist GroupKeys(stringlist keys, u32list group_index, ptr exec_ctx) + +## GroupSum +Per-group sum of `values`. The output has one entry per distinct group, in the same order as `GroupKeys`. Signed integers promote to `i64`, unsigned to `u64`, floats to `f64` — matching the ungrouped `Sum`. `values.len` must equal `group_index.len`. + + i64list GroupSum(i8list values, u32list group_index, ptr exec_ctx) + i64list GroupSum(i16list values, u32list group_index, ptr exec_ctx) + i64list GroupSum(i32list values, u32list group_index, ptr exec_ctx) + i64list GroupSum(i64list values, u32list group_index, ptr exec_ctx) + u64list GroupSum(u8list values, u32list group_index, ptr exec_ctx) + u64list GroupSum(u16list values, u32list group_index, ptr exec_ctx) + u64list GroupSum(u32list values, u32list group_index, ptr exec_ctx) + u64list GroupSum(u64list values, u32list group_index, ptr exec_ctx) + f64list GroupSum(f32list values, u32list group_index, ptr exec_ctx) + f64list GroupSum(f64list values, u32list group_index, ptr exec_ctx) + +## GroupMax +Per-group maximum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Max`). `values.len` must equal `group_index.len`. + + u8list GroupMax(u8list values, u32list group_index, ptr exec_ctx) + i8list GroupMax(i8list values, u32list group_index, ptr exec_ctx) + u16list GroupMax(u16list values, u32list group_index, ptr exec_ctx) + i16list GroupMax(i16list values, u32list group_index, ptr exec_ctx) + u32list GroupMax(u32list values, u32list group_index, ptr exec_ctx) + i32list GroupMax(i32list values, u32list group_index, ptr exec_ctx) + u64list GroupMax(u64list values, u32list group_index, ptr exec_ctx) + i64list GroupMax(i64list values, u32list group_index, ptr exec_ctx) + f32list GroupMax(f32list values, u32list group_index, ptr exec_ctx) + f64list GroupMax(f64list values, u32list group_index, ptr exec_ctx) + +## GroupMin +Per-group minimum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Min`). `values.len` must equal `group_index.len`. + + u8list GroupMin(u8list values, u32list group_index, ptr exec_ctx) + i8list GroupMin(i8list values, u32list group_index, ptr exec_ctx) + u16list GroupMin(u16list values, u32list group_index, ptr exec_ctx) + i16list GroupMin(i16list values, u32list group_index, ptr exec_ctx) + u32list GroupMin(u32list values, u32list group_index, ptr exec_ctx) + i32list GroupMin(i32list values, u32list group_index, ptr exec_ctx) + u64list GroupMin(u64list values, u32list group_index, ptr exec_ctx) + i64list GroupMin(i64list values, u32list group_index, ptr exec_ctx) + f32list GroupMin(f32list values, u32list group_index, ptr exec_ctx) + f64list GroupMin(f64list values, u32list group_index, ptr exec_ctx) + +## GroupAvg +Per-group average of `values`. Output is always `f64list` with one entry per distinct group, matching the ungrouped `Avg`. `values.len` must equal `group_index.len`. + + f64list GroupAvg(u8list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(i8list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(u16list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(i16list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(u32list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(i32list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(u64list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(i64list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(f32list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(f64list values, u32list group_index, ptr exec_ctx) + ## GetAt Get the element at the specified index from the list. Returns the default value (0 for numeric types) if the index is out of bounds. diff --git a/src/function/list_group.cc b/src/function/list_group.cc index ac36452..9294137 100644 --- a/src/function/list_group.cc +++ b/src/function/list_group.cc @@ -4,13 +4,21 @@ * @Last Modified by: victorika * @Last Modified time: 2026-04-30 11:35:00 */ +#include #include +#include +#include +#include #include #include +#include +#include "codegen/codegen.h" #include "exec_engine.h" #include "function_init.h" #include "function_registry.h" +#include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/Type.h" #include "status.h" #include "type.h" @@ -58,9 +66,122 @@ U32ListStruct GroupIndexString(StringListStruct keys, void *exec_context) { return result; } -} // namespace +uint32_t GroupCount(U32ListStruct group_index) { + if (group_index.len == 0) { + return 0; + } + uint32_t max_id = 0; + for (uint32_t i = 0; i < group_index.len; ++i) { + max_id = std::max(group_index.data[i], max_id); + } + return max_id + 1; +} -Status InitListGroupFunc(FunctionRegistry *reg) { +template +KList GroupKeys(KList keys, U32ListStruct group_index, uint32_t distinct, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + if (keys.len != group_index.len) { + exec_ctx->AddError("GroupKeys: keys and group_index len mismatch, keys len: " + std::to_string(keys.len) + + ", group_index len: " + std::to_string(group_index.len)); + return {nullptr, 0}; + } + KList result; + result.data = reinterpret_cast( + exec_ctx->arena.Allocate(sizeof(typename KList::CElementType) * distinct)); + uint32_t filled = 0; + for (uint32_t i = 0; i < keys.len; ++i) { + if (group_index.data[i] == filled) { + result.data[filled++] = keys.data[i]; + } + } + result.len = filled; + return result; +} + +template +AccList GroupSum(VList values, U32ListStruct group_index, uint32_t distinct, void *exec_context) { + using Acc = typename AccList::CElementType; + auto *exec_ctx = reinterpret_cast(exec_context); + if (values.len != group_index.len) { + exec_ctx->AddError("GroupSum: values and group_index len mismatch, values len: " + std::to_string(values.len) + + ", group_index len: " + std::to_string(group_index.len)); + return {nullptr, 0}; + } + AccList result; + result.len = distinct; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(Acc) * distinct)); + std::memset(result.data, 0, sizeof(Acc) * distinct); + for (uint32_t i = 0; i < values.len; ++i) { + result.data[group_index.data[i]] += values.data[i]; + } + return result; +} + +template +VList GroupMax(VList values, U32ListStruct group_index, uint32_t distinct, void *exec_context) { + using V = typename VList::CElementType; + auto *exec_ctx = reinterpret_cast(exec_context); + if (values.len != group_index.len) { + exec_ctx->AddError("GroupMax: values and group_index len mismatch, values len: " + std::to_string(values.len) + + ", group_index len: " + std::to_string(group_index.len)); + return {nullptr, 0}; + } + VList result; + result.len = distinct; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(V) * distinct)); + V seed = std::numeric_limits::lowest(); + std::fill_n(result.data, distinct, seed); + for (uint32_t i = 0; i < values.len; ++i) { + result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); + } + return result; +} + +template +VList GroupMin(VList values, U32ListStruct group_index, uint32_t distinct, void *exec_context) { + using V = typename VList::CElementType; + auto *exec_ctx = reinterpret_cast(exec_context); + if (values.len != group_index.len) { + exec_ctx->AddError("GroupMin: values and group_index len mismatch, values len: " + std::to_string(values.len) + + ", group_index len: " + std::to_string(group_index.len)); + return {nullptr, 0}; + } + VList result; + result.len = distinct; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(V) * distinct)); + V seed = std::numeric_limits::max(); + std::fill_n(result.data, distinct, seed); + for (uint32_t i = 0; i < values.len; ++i) { + result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); + } + return result; +} + +template +F64ListStruct GroupAvg(VList values, U32ListStruct group_index, uint32_t distinct, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + if (values.len != group_index.len) { + exec_ctx->AddError("GroupAvg: values and group_index len mismatch, values len: " + std::to_string(values.len) + + ", group_index len: " + std::to_string(group_index.len)); + return {nullptr, 0}; + } + F64ListStruct result; + result.len = distinct; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(double) * distinct)); + std::memset(result.data, 0, sizeof(double) * distinct); + std::vector local_counts(distinct, 0); + for (uint32_t i = 0; i < values.len; ++i) { + auto gid = group_index.data[i]; + result.data[gid] += values.data[i]; + local_counts[gid] += 1; + } + for (uint32_t g = 0; g < distinct; ++g) { + result.data[g] /= local_counts[g]; + } + return result; +} + +Status InitGroupIndexFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( FunctionSignature("GroupIndex", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(GroupIndex))); @@ -97,4 +218,557 @@ Status InitListGroupFunc(FunctionRegistry *reg) { return Status::OK(); } +Status InitGroupCountFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("GroupCount", {ValueType::kU32List}, ValueType::kU32), + reinterpret_cast(GroupCount))); + return Status::OK(); +} + +Status InitGroupKeysFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU8List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI8List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU16List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI16List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI32List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF32List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupKeys))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kStringList), + reinterpret_cast(GroupKeys))); + return Status::OK(); +} + +llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + auto *keys_value = arg_llvm_value_list.at(0); + auto *group_index_value = arg_llvm_value_list.at(1); + auto *exec_context_value = arg_llvm_value_list.at(2); + auto *keys_llvm_type = arg_llvm_type_list.at(0); + + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + auto *u32list_llvm_type = ctx.complex_type.u32list_type; + + FunctionSignature group_count_sign("GroupCount", {ValueType::kU32List}, ValueType::kU32); + auto *group_count_func_type = llvm::FunctionType::get(i32_ty, {u32list_llvm_type}, false); + llvm::FunctionCallee group_count_callee = + ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); + llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + + FunctionSignature group_keys_sign("GroupKeys", + {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + sign.GetRetType()); + auto *group_keys_func_type = + llvm::FunctionType::get(keys_llvm_type, {keys_llvm_type, u32list_llvm_type, i32_ty, ptr_ty}, false); + llvm::FunctionCallee group_keys_callee = + ctx.module.getOrInsertFunction(group_keys_sign.ToString(), group_keys_func_type); + return ctx.builder.CreateCall(group_keys_callee, {keys_value, group_index_value, distinct_value, exec_context_value}, + "group_keys"); +} + +Status InitGroupKeysSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupKeysSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kPtr}, + ValueType::kStringList), + EmitGroupKeysSugar)); + return Status::OK(); +} + +Status InitGroupSumFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupSum))); + // Unsigned integers promote to u64. + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupSum))); + // Floating-point promotes to f64. + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupSum))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupSum))); + return Status::OK(); +} + +llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + auto *values_value = arg_llvm_value_list.at(0); + auto *group_index_value = arg_llvm_value_list.at(1); + auto *exec_context_value = arg_llvm_value_list.at(2); + auto *values_llvm_type = arg_llvm_type_list.at(0); + + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + auto *u32list_llvm_type = ctx.complex_type.u32list_type; + + llvm::Type *acc_llvm_type = nullptr; + (void)CodeGen::ValueTypeToLLVMType(ctx, sign.GetRetType(), &acc_llvm_type); + + FunctionSignature group_count_sign("GroupCount", {ValueType::kU32List}, ValueType::kU32); + auto *group_count_func_type = llvm::FunctionType::get(i32_ty, {u32list_llvm_type}, false); + llvm::FunctionCallee group_count_callee = + ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); + llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + + FunctionSignature group_sum_sign("GroupSum", + {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + sign.GetRetType()); + auto *group_sum_func_type = + llvm::FunctionType::get(acc_llvm_type, {values_llvm_type, u32list_llvm_type, i32_ty, ptr_ty}, false); + llvm::FunctionCallee group_sum_callee = + ctx.module.getOrInsertFunction(group_sum_sign.ToString(), group_sum_func_type); + return ctx.builder.CreateCall(group_sum_callee, {values_value, group_index_value, distinct_value, exec_context_value}, + "group_sum"); +} + +Status InitGroupSumSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupSumSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupSumSugar)); + return Status::OK(); +} + +Status InitGroupMaxFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU8List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI8List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU16List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI16List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI32List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF32List), + reinterpret_cast(GroupMax))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupMax))); + return Status::OK(); +} + +Status InitGroupMinFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU8List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI8List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU16List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI16List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI32List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF32List), + reinterpret_cast(GroupMin))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupMin))); + return Status::OK(); +} + +llvm::Value *EmitGroupExtremaSugar(const std::string &kernel_name, const FunctionSignature &sign, + const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx, + const char *call_name) { + auto *values_value = arg_llvm_value_list.at(0); + auto *group_index_value = arg_llvm_value_list.at(1); + auto *exec_context_value = arg_llvm_value_list.at(2); + auto *values_llvm_type = arg_llvm_type_list.at(0); + + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + auto *u32list_llvm_type = ctx.complex_type.u32list_type; + + FunctionSignature group_count_sign("GroupCount", {ValueType::kU32List}, ValueType::kU32); + auto *group_count_func_type = llvm::FunctionType::get(i32_ty, {u32list_llvm_type}, false); + llvm::FunctionCallee group_count_callee = + ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); + llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + + FunctionSignature kernel_sign(kernel_name, + {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + sign.GetRetType()); + auto *kernel_func_type = + llvm::FunctionType::get(values_llvm_type, {values_llvm_type, u32list_llvm_type, i32_ty, ptr_ty}, false); + llvm::FunctionCallee kernel_callee = ctx.module.getOrInsertFunction(kernel_sign.ToString(), kernel_func_type); + return ctx.builder.CreateCall(kernel_callee, {values_value, group_index_value, distinct_value, exec_context_value}, + call_name); +} + +llvm::Value *EmitGroupMaxSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + return EmitGroupExtremaSugar("GroupMax", sign, arg_llvm_type_list, arg_llvm_value_list, ctx, "group_max"); +} + +llvm::Value *EmitGroupMinSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + return EmitGroupExtremaSugar("GroupMin", sign, arg_llvm_type_list, arg_llvm_value_list, ctx, "group_min"); +} + +Status InitGroupMaxSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + EmitGroupMaxSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupMaxSugar)); + return Status::OK(); +} + +Status InitGroupMinSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + EmitGroupMinSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupMinSugar)); + return Status::OK(); +} + +Status InitGroupAvgFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(GroupAvg))); + return Status::OK(); +} + +llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + auto *values_value = arg_llvm_value_list.at(0); + auto *group_index_value = arg_llvm_value_list.at(1); + auto *exec_context_value = arg_llvm_value_list.at(2); + auto *values_llvm_type = arg_llvm_type_list.at(0); + + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + auto *u32list_llvm_type = ctx.complex_type.u32list_type; + + llvm::Type *acc_llvm_type = nullptr; + (void)CodeGen::ValueTypeToLLVMType(ctx, sign.GetRetType(), &acc_llvm_type); + + FunctionSignature group_count_sign("GroupCount", {ValueType::kU32List}, ValueType::kU32); + auto *group_count_func_type = llvm::FunctionType::get(i32_ty, {u32list_llvm_type}, false); + llvm::FunctionCallee group_count_callee = + ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); + llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + + FunctionSignature group_avg_sign("GroupAvg", + {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + sign.GetRetType()); + auto *group_avg_func_type = + llvm::FunctionType::get(acc_llvm_type, {values_llvm_type, u32list_llvm_type, i32_ty, ptr_ty}, false); + llvm::FunctionCallee group_avg_callee = + ctx.module.getOrInsertFunction(group_avg_sign.ToString(), group_avg_func_type); + return ctx.builder.CreateCall(group_avg_callee, {values_value, group_index_value, distinct_value, exec_context_value}, + "group_avg"); +} + +Status InitGroupAvgSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + EmitGroupAvgSugar)); + return Status::OK(); +} + +} // namespace + +Status InitListGroupFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(InitGroupIndexFunc(reg)); + JF_RETURN_NOT_OK(InitGroupCountFunc(reg)); + JF_RETURN_NOT_OK(InitGroupKeysFunc(reg)); + JF_RETURN_NOT_OK(InitGroupKeysSugarFunc(reg)); + JF_RETURN_NOT_OK(InitGroupSumFunc(reg)); + JF_RETURN_NOT_OK(InitGroupSumSugarFunc(reg)); + JF_RETURN_NOT_OK(InitGroupMaxFunc(reg)); + JF_RETURN_NOT_OK(InitGroupMaxSugarFunc(reg)); + JF_RETURN_NOT_OK(InitGroupMinFunc(reg)); + JF_RETURN_NOT_OK(InitGroupMinSugarFunc(reg)); + JF_RETURN_NOT_OK(InitGroupAvgFunc(reg)); + JF_RETURN_NOT_OK(InitGroupAvgSugarFunc(reg)); + return Status::OK(); +} + } // namespace jitfusion diff --git a/test/list_group_test.cc b/test/list_group_test.cc index edab3ad..e6915fe 100644 --- a/test/list_group_test.cc +++ b/test/list_group_test.cc @@ -197,4 +197,1199 @@ TEST(ListGroupTest, GroupIndexResultLenMatchesInputLen) { EXPECT_EQ(std::get>(result).size(), 7U); } +namespace { + +// Builds: GroupCount(GroupIndex(keys)). GroupCount is a pure readonly +// computation so no ExecContext argument is needed. +std::unique_ptr MakeGroupCountCall(std::unique_ptr keys_node) { + std::vector> args; + args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); + return std::unique_ptr(new FunctionNode("GroupCount", std::move(args))); +} + +Status RunGroupCount(std::unique_ptr expr, RetType *result) { + std::unique_ptr func_registry; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); + if (!st.ok()) { + return st; + } + ExecEngine engine; + st = engine.Compile(expr, func_registry); + if (!st.ok()) { + return st; + } + return engine.Execute(nullptr, result); +} + +} // namespace + +TEST(ListGroupTest, GroupCountEmptyI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 0U); +} + +TEST(ListGroupTest, GroupCountSingleElementI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 1U); +} + +TEST(ListGroupTest, GroupCountAllSameI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 1U); +} + +TEST(ListGroupTest, GroupCountAllDistinctI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40, 50})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 5U); +} + +TEST(ListGroupTest, GroupCountInterleavedI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5, 3, 5, 3})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 4U); +} + +TEST(ListGroupTest, GroupCountString) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"apple", "banana", "apple", "cherry", "banana", "apple"})); + RetType result; + ASSERT_TRUE(RunGroupCount(MakeGroupCountCall(std::move(list)), &result).ok()); + EXPECT_EQ(std::get(result), 3U); +} + +namespace { + +// Builds: GroupKeys(keys, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). +// The keys node is cloned so the same logical list feeds every argument, +// mirroring how CSE would share the GroupIndex / GroupCount sub-expressions +// with other aggregates in a real pipeline. +std::unique_ptr MakeGroupKeysCall(std::unique_ptr keys_node) { + auto keys_for_index = keys_node->Clone(); + auto keys_for_count = keys_node->Clone(); + std::vector> args; + args.emplace_back(std::move(keys_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); + args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); +} + +Status RunGroupKeys(std::unique_ptr expr, RetType *result) { + std::unique_ptr func_registry; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); + if (!st.ok()) { + return st; + } + ExecEngine engine; + st = engine.Compile(expr, func_registry); + if (!st.ok()) { + return st; + } + return engine.Execute(nullptr, result); +} + +} // namespace + +TEST(ListGroupTest, GroupKeysEmptyI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupKeysSingleElementI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {42}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysAllSameI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {7}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysAllDistinctI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40, 50})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {10, 20, 30, 40, 50}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysInterleavedI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5, 3, 5, 3})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {3, 1, 4, 5}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysU8) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 5, 2, 5, 9})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {2, 5, 9}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysI8Negatives) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1, -2, -1, -3, -2})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {-1, -2, -3}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysU16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{100, 200, 100, 300})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {100, 200, 300}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysI16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1000, 1000, -1000})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {-1000, 1000}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysU32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1U, 1U, 2U})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {1U, 2U}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysU64Large) { + auto list = std::unique_ptr(new ConstantListValueNode( + std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysI64) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-9LL, 9LL, -9LL, 0LL})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {-9LL, 9LL, 0LL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysF32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1.5F, 2.5F, 1.5F, 3.5F, 2.5F})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {1.5F, 2.5F, 3.5F}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysF64) { + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{3.14, 2.72, 3.14, 1.41, 2.72, 3.14})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {3.14, 2.72, 1.41}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysString) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"apple", "banana", "apple", "cherry", "banana", "apple"})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {"apple", "banana", "cherry"}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysStringEmpty) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupKeysStringWithEmptyStrings) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {"", "a", "b"}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysStringDifferentLengths) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {"ab", "abc", "abcd"}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysPreservesFirstAppearanceOrder) { + // Distinct keys must come out in the order of their first occurrence, not + // sorted and not in hash-table order. + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{100, 50, 100, 75, 50, 25, 75, 100})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); + std::vector expected = {100, 50, 75, 25}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { + // keys has 4 elements, group_index has 3 -> must surface a runtime error + // instead of silently truncating. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + std::vector> args; + args.emplace_back(std::move(keys)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); + + RetType result; + Status st = RunGroupKeys(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupKeys"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +namespace { + +// Builds the 3-arg sugar form: GroupKeys(keys, GroupIndex(keys), exec_ctx). +// This is the user-facing call registered as an LLVM intrinsic that expands +// at IR time into GroupCount + the canonical 4-arg GroupKeys kernel, letting +// GVN share the distinct-count computation with other aggregates. The +// trailing exec_context keeps the call shape consistent with other DSL +// functions (GroupIndex, etc.). +std::unique_ptr MakeGroupKeysSugarCall(std::unique_ptr keys_node) { + auto keys_for_index = keys_node->Clone(); + std::vector> args; + args.emplace_back(std::move(keys_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); +} + +} // namespace + +TEST(ListGroupTest, GroupKeysSugarEmptyI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupKeysSugarSingleElementI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {42}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarAllSameI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {7}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarAllDistinctI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40, 50})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {10, 20, 30, 40, 50}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarInterleavedI32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5, 3, 5, 3})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {3, 1, 4, 5}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarU8) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 5, 2, 5, 9})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {2, 5, 9}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarI8Negatives) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1, -2, -1, -3, -2})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {-1, -2, -3}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarU16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{100, 200, 100, 300})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {100, 200, 300}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarI16) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-1000, 1000, -1000})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {-1000, 1000}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarU32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1U, 1U, 2U})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {1U, 2U}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarU64Large) { + auto list = std::unique_ptr(new ConstantListValueNode( + std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarI64) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{-9LL, 9LL, -9LL, 0LL})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {-9LL, 9LL, 0LL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarF32) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{1.5F, 2.5F, 1.5F, 3.5F, 2.5F})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {1.5F, 2.5F, 3.5F}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarF64) { + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{3.14, 2.72, 3.14, 1.41, 2.72, 3.14})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {3.14, 2.72, 1.41}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarString) { + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{"apple", "banana", "apple", "cherry", "banana", "apple"})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + std::vector expected = {"apple", "banana", "cherry"}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupKeysSugarStringEmpty) { + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupKeysSugarLenMismatchReturnsError) { + // The sugar form forwards exec_context to the 4-arg kernel, which must still + // surface the same "len mismatch" runtime error path. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + std::vector> args; + args.emplace_back(std::move(keys)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); + + RetType result; + Status st = RunGroupKeys(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupKeys"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +namespace { + +// Builds: GroupSum(values, GroupIndex(keys), exec_ctx). Sugar form, same call +// shape as the user-facing DSL -- the IR-level expansion adds GroupCount and +// routes to the 4-arg kernel. Keys and values are separate nodes because they +// may be of different element types. +std::unique_ptr MakeGroupSumSugarCall(std::unique_ptr values_node, + std::unique_ptr keys_node) { + std::vector> args; + args.emplace_back(std::move(values_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); +} + +// Builds: GroupSum(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). +// Exercises the raw 4-arg kernel directly so its contract is covered +// independently of the sugar-layer expansion. +std::unique_ptr MakeGroupSumKernelCall(std::unique_ptr values_node, + std::unique_ptr keys_node) { + auto keys_for_count = keys_node->Clone(); + std::vector> args; + args.emplace_back(std::move(values_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); + args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); +} + +Status RunGroupSum(std::unique_ptr expr, RetType *result) { + std::unique_ptr func_registry; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); + if (!st.ok()) { + return st; + } + ExecEngine engine; + st = engine.Compile(expr, func_registry); + if (!st.ok()) { + return st; + } + return engine.Execute(nullptr, result); +} + +} // namespace + +// ---- GroupSum sugar form tests --------------------------------------------- + +TEST(ListGroupTest, GroupSumSugarI32) { + // keys: {10, 20, 10, 30, 20, 10} -> gids: {0, 1, 0, 2, 1, 0} + // values: {1, 2, 3, 4, 5, 6} -> groups: [1+3+6=10, 2+5=7, 4] + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {10, 7, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarI8NegativeValues) { + // Exercise i8 -> i64 promotion with negative values. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 1, 2, 1, 2})); + auto values = + std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -30, -40, 50})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + // group 0: -10 + 20 + (-40) = -30; group 1: -30 + 50 = 20 + std::vector expected = {-30, 20}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarI16) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 2})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1000, -1000, 2000, 3000})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {3000, 2000}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarI64) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1})); + auto values = std::unique_ptr( + new ConstantListValueNode(std::vector{1LL << 40, 1LL << 41, -(1LL << 40)})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {0, 1LL << 41}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarU8) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 2, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{250, 200, 100, 50, 150})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + // u8 promotes to u64, so 250 + 100 does not overflow. + std::vector expected = {350U, 350U, 50U}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarU64Large) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode( + std::vector{0xFFFFFFFFFFFFFFFEULL, 1ULL, 42ULL})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + // Group 0 sums exactly to UINT64_MAX. + std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 42ULL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarF32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1.5F, 2.5F, 3.5F, 4.5F})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {5.0, 7.0}; + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), expected.size()); + for (size_t i = 0; i < expected.size(); ++i) { + EXPECT_DOUBLE_EQ(actual[i], expected[i]); + } +} + +TEST(ListGroupTest, GroupSumSugarF64) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1, 2})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{0.1, 0.2, 0.3, 0.4, 0.5})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {0.4, 0.6, 0.5}; + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), expected.size()); + for (size_t i = 0; i < expected.size(); ++i) { + EXPECT_DOUBLE_EQ(actual[i], expected[i]); + } +} + +TEST(ListGroupTest, GroupSumSugarEmpty) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupSumSugarAllSameGroup) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {10}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarAllDistinctGroups) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {1, 2, 3, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumSugarStringKeys) { + // keys are strings, values are numeric. GroupIndex handles the string keys; + // GroupSum just operates on the resulting u32 group_index, so this exercises + // the full "keys can be anything, values can be anything" combination. + auto keys = std::unique_ptr( + new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); + // "a": 1+3+6=10, "b": 2+5=7, "c": 4 + std::vector expected = {10, 7, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +// ---- GroupSum kernel (4-arg) tests ----------------------------------------- + +TEST(ListGroupTest, GroupSumKernelI32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumKernelCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {10, 7, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumKernelU32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{100U, 200U, 300U})); + RetType result; + ASSERT_TRUE(RunGroupSum(MakeGroupSumKernelCall(std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {400U, 200U}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupSumKernelSugarAgreeF64) { + // Direct equivalence check between the sugar and the kernel on the same + // inputs -- protects against future divergence (e.g. if sugar starts + // passing a different `distinct`). + auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); + auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + RetType sugar_result; + ASSERT_TRUE( + RunGroupSum(MakeGroupSumSugarCall(std::move(values_sugar), std::move(keys_sugar)), &sugar_result).ok()); + + auto keys_kernel = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); + auto values_kernel = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + RetType kernel_result; + ASSERT_TRUE( + RunGroupSum(MakeGroupSumKernelCall(std::move(values_kernel), std::move(keys_kernel)), &kernel_result).ok()); + + auto &sugar_vec = std::get>(sugar_result); + auto &kernel_vec = std::get>(kernel_result); + ASSERT_EQ(sugar_vec.size(), kernel_vec.size()); + for (size_t i = 0; i < sugar_vec.size(); ++i) { + EXPECT_DOUBLE_EQ(sugar_vec[i], kernel_vec[i]); + } +} + +// ---- GroupSum error paths -------------------------------------------------- + +TEST(ListGroupTest, GroupSumLenMismatchReturnsError) { + // values has 3 elements, group_index has 4 -> kernel must surface a runtime + // error, same shape as GroupKeys len-mismatch handling. + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); + + RetType result; + Status st = RunGroupSum(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupSum"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +TEST(ListGroupTest, GroupSumSugarLenMismatchReturnsError) { + // Same kind of mismatch reached through the sugar form, to prove the error + // propagates across the IR-level expansion. + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); + + RetType result; + Status st = RunGroupSum(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupSum"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +namespace { + +// Generic builder for a per-group aggregate sugar call of shape +// `(values, GroupIndex(keys), exec_ctx)`. Used by GroupMax / GroupMin +// tests and ready to be reused by later aggregates (Avg, ...). +std::unique_ptr MakeGroupAggSugarCall(const std::string &func_name, std::unique_ptr values_node, + std::unique_ptr keys_node) { + std::vector> args; + args.emplace_back(std::move(values_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +// Same as above but for the raw 4-arg kernel: +// `(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx)` +std::unique_ptr MakeGroupAggKernelCall(const std::string &func_name, std::unique_ptr values_node, + std::unique_ptr keys_node) { + auto keys_for_count = keys_node->Clone(); + std::vector> args; + args.emplace_back(std::move(values_node)); + args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); + args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + return std::unique_ptr(new FunctionNode(func_name, std::move(args))); +} + +Status RunGroupAgg(std::unique_ptr expr, RetType *result) { + std::unique_ptr func_registry; + auto st = FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); + if (!st.ok()) { + return st; + } + ExecEngine engine; + st = engine.Compile(expr, func_registry); + if (!st.ok()) { + return st; + } + return engine.Execute(nullptr, result); +} + +} // namespace + +// ---- GroupMax sugar form tests --------------------------------------------- + +TEST(ListGroupTest, GroupMaxSugarI32) { + // keys: {10, 20, 10, 30, 20, 10} -> gids: {0, 1, 0, 2, 1, 0} + // values: {1, 5, 3, 4, 2, 6} -> maxes per group: {6, 5, 4} + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 5, 3, 4, 2, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {6, 5, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMaxSugarI8AllNegative) { + // All-negative values must still pick the max (closest to zero), which + // only works correctly if the seed is numeric_limits::lowest() (-128), + // not 0. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-30, -10, -100, -50})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {-10, -50}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMaxSugarU8) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{10, 250, 0, 128, 64})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {250, 128}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMaxSugarF64) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-1.5, 2.5, -3.5, 0.5})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 2U); + EXPECT_DOUBLE_EQ(actual[0], -1.5); + EXPECT_DOUBLE_EQ(actual[1], 2.5); +} + +TEST(ListGroupTest, GroupMaxSugarSingleton) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-7})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {-7}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMaxSugarEmpty) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupMaxSugarStringKeys) { + auto keys = std::unique_ptr( + new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + // "a": max(1,5,3)=5, "b": max(7,2)=7, "c": 4 + std::vector expected = {5, 7, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +// ---- GroupMax kernel (4-arg) tests ----------------------------------------- + +TEST(ListGroupTest, GroupMaxKernelI32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 5, 3, 4, 2, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggKernelCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {6, 5, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +// ---- GroupMin sugar form tests --------------------------------------------- + +TEST(ListGroupTest, GroupMinSugarI32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 5, 3, 4, 2, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {1, 2, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMinSugarI8AllPositive) { + // All-positive values must still pick the smallest, which only works + // correctly if the seed is numeric_limits::max() (127), not 0. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{30, 10, 100, 50})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {10, 50}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMinSugarU64Large) { + // Use values close to UINT64_MAX to prove the seed is max(), which is the + // only value they can all be less-or-equal to. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode( + std::vector{0xFFFFFFFFFFFFFFF0ULL, 0xFFFFFFFFFFFFFFFEULL, 0xFFFFFFFFFFFFFFFFULL})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {0xFFFFFFFFFFFFFFF0ULL, 0xFFFFFFFFFFFFFFFFULL}; + EXPECT_EQ(std::get>(result), expected); +} + +TEST(ListGroupTest, GroupMinSugarF64) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1.5, 2.5, -3.5, 0.5})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 2U); + EXPECT_DOUBLE_EQ(actual[0], -3.5); + EXPECT_DOUBLE_EQ(actual[1], 0.5); +} + +TEST(ListGroupTest, GroupMinSugarEmpty) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupMinSugarStringKeys) { + auto keys = std::unique_ptr( + new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + // "a": min(1,5,3)=1, "b": min(7,2)=2, "c": 4 + std::vector expected = {1, 2, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +// ---- GroupMin kernel (4-arg) tests ----------------------------------------- + +TEST(ListGroupTest, GroupMinKernelI32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 5, 3, 4, 2, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggKernelCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); + std::vector expected = {1, 2, 4}; + EXPECT_EQ(std::get>(result), expected); +} + +// ---- Cross-agg correctness check ------------------------------------------- + +TEST(ListGroupTest, GroupMaxMinConsistency) { + // For any non-empty group, max(group) >= min(group). Sanity check that both + // kernels agree on which groups exist and produce the expected ordering. + auto keys_max = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1, 2})); + auto values_max = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5})); + RetType max_result; + ASSERT_TRUE( + RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values_max), std::move(keys_max)), &max_result).ok()); + + auto keys_min = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1, 2})); + auto values_min = std::unique_ptr(new ConstantListValueNode(std::vector{3, 1, 4, 1, 5})); + RetType min_result; + ASSERT_TRUE( + RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values_min), std::move(keys_min)), &min_result).ok()); + + auto &maxes = std::get>(max_result); + auto &mins = std::get>(min_result); + ASSERT_EQ(maxes.size(), mins.size()); + for (size_t i = 0; i < maxes.size(); ++i) { + EXPECT_GE(maxes[i], mins[i]); + } +} + +// ---- GroupMax/GroupMin error paths ----------------------------------------- + +TEST(ListGroupTest, GroupMaxSugarLenMismatchReturnsError) { + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupMax", std::move(args))); + + RetType result; + Status st = RunGroupAgg(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupMax"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +TEST(ListGroupTest, GroupMinSugarLenMismatchReturnsError) { + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupMin", std::move(args))); + + RetType result; + Status st = RunGroupAgg(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupMin"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +// ---- GroupAvg sugar form tests --------------------------------------------- + +TEST(ListGroupTest, GroupAvgSugarI32) { + // keys: {10, 20, 10, 30, 20, 10} -> gids: {0, 1, 0, 2, 1, 0} + // values: {1, 2, 3, 4, 5, 6} + // group 0: (1+3+6)/3 = 10/3 + // group 1: (2+5)/2 = 3.5 + // group 2: 4/1 = 4.0 + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 3U); + EXPECT_DOUBLE_EQ(actual[0], 10.0 / 3.0); + EXPECT_DOUBLE_EQ(actual[1], 3.5); + EXPECT_DOUBLE_EQ(actual[2], 4.0); +} + +TEST(ListGroupTest, GroupAvgSugarI8NegativeValues) { + // Integer input must promote to double (so -5/2 == -2.5, not -2). The seed + // is 0.0, summation accumulates into double, division is floating. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -3, -2})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 2U); + EXPECT_DOUBLE_EQ(actual[0], 5.0); // (-10 + 20) / 2 + EXPECT_DOUBLE_EQ(actual[1], -2.5); // (-3 + -2) / 2 <-- int would round to -2 +} + +TEST(ListGroupTest, GroupAvgSugarU64) { + // Unsigned i64 values promote to double. Accept small precision loss at + // the ulp level, which is why we test with a modest magnitude. + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{100, 200, 300, 400})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 2U); + EXPECT_DOUBLE_EQ(actual[0], 200.0); // (100 + 300) / 2 + EXPECT_DOUBLE_EQ(actual[1], 300.0); // (200 + 400) / 2 +} + +TEST(ListGroupTest, GroupAvgSugarF32) { + // f32 input still returns F64List (same promotion as ungrouped Avg). + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1, 1})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1.5F, 2.5F, 3.5F, 4.5F})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 2U); + EXPECT_DOUBLE_EQ(actual[0], 2.0); + EXPECT_DOUBLE_EQ(actual[1], 4.0); +} + +TEST(ListGroupTest, GroupAvgSugarF64) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 1, 0, 1, 2})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{0.1, 0.2, 0.3, 0.4, 0.5})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 3U); + EXPECT_DOUBLE_EQ(actual[0], 0.2); // (0.1 + 0.3) / 2 + EXPECT_DOUBLE_EQ(actual[1], 0.3); // (0.2 + 0.4) / 2 + EXPECT_DOUBLE_EQ(actual[2], 0.5); +} + +TEST(ListGroupTest, GroupAvgSugarSingleton) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{42})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-7})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 1U); + EXPECT_DOUBLE_EQ(actual[0], -7.0); +} + +TEST(ListGroupTest, GroupAvgSugarEmpty) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListGroupTest, GroupAvgSugarAllSameGroup) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{7, 7, 7, 7})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 1U); + EXPECT_DOUBLE_EQ(actual[0], 2.5); // (1+2+3+4)/4 +} + +TEST(ListGroupTest, GroupAvgSugarAllDistinctGroups) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + std::vector expected = {1.0, 2.0, 3.0, 4.0}; + ASSERT_EQ(actual.size(), expected.size()); + for (size_t i = 0; i < expected.size(); ++i) { + EXPECT_DOUBLE_EQ(actual[i], expected[i]); + } +} + +TEST(ListGroupTest, GroupAvgSugarStringKeys) { + auto keys = std::unique_ptr( + new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 3U); + EXPECT_DOUBLE_EQ(actual[0], 10.0 / 3.0); // "a": (1+3+6)/3 + EXPECT_DOUBLE_EQ(actual[1], 3.5); // "b": (2+5)/2 + EXPECT_DOUBLE_EQ(actual[2], 4.0); // "c": 4 +} + +// ---- GroupAvg kernel (4-arg) tests ----------------------------------------- + +TEST(ListGroupTest, GroupAvgKernelI32) { + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 10, 30, 20, 10})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggKernelCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 3U); + EXPECT_DOUBLE_EQ(actual[0], 10.0 / 3.0); + EXPECT_DOUBLE_EQ(actual[1], 3.5); + EXPECT_DOUBLE_EQ(actual[2], 4.0); +} + +TEST(ListGroupTest, GroupAvgKernelSugarAgreeF64) { + // Direct equivalence check: sugar and raw kernel must produce identical + // results given identical inputs. Guards against future divergence (e.g. + // sugar starting to pass a different `distinct` than GroupCount). + auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); + auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + RetType sugar_result; + ASSERT_TRUE( + RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values_sugar), std::move(keys_sugar)), &sugar_result) + .ok()); + + auto keys_kernel = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); + auto values_kernel = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + RetType kernel_result; + ASSERT_TRUE( + RunGroupAgg(MakeGroupAggKernelCall("GroupAvg", std::move(values_kernel), std::move(keys_kernel)), &kernel_result) + .ok()); + + auto &sugar_vec = std::get>(sugar_result); + auto &kernel_vec = std::get>(kernel_result); + ASSERT_EQ(sugar_vec.size(), kernel_vec.size()); + for (size_t i = 0; i < sugar_vec.size(); ++i) { + EXPECT_DOUBLE_EQ(sugar_vec[i], kernel_vec[i]); + } +} + +// ---- GroupAvg cross-agg identity ------------------------------------------ + +TEST(ListGroupTest, GroupAvgMatchesSumOverCount) { + // For any non-empty group, Avg[g] must equal Sum[g] / count[g]. We compute + // count[g] by Avg(1, key) which gives 1.0 per group (so count = n_g), then + // reconstruct n_g from group_index length and distinct. Simpler: compare + // Avg to an inline mean. This guards against any off-by-one in the counts + // array (e.g. forgetting to memset it). + auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 2, 1, 3})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{10, 20, 30, 40, 50, 60})); + RetType result; + ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); + auto &actual = std::get>(result); + ASSERT_EQ(actual.size(), 3U); + // group 0 (key=1): (10+30+50)/3 = 30 + // group 1 (key=2): (20+40)/2 = 30 + // group 2 (key=3): 60/1 = 60 + EXPECT_DOUBLE_EQ(actual[0], 30.0); + EXPECT_DOUBLE_EQ(actual[1], 30.0); + EXPECT_DOUBLE_EQ(actual[2], 60.0); +} + +// ---- GroupAvg error paths -------------------------------------------------- + +TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); + + RetType result; + Status st = RunGroupAgg(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupAvg"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + +TEST(ListGroupTest, GroupAvgSugarLenMismatchReturnsError) { + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); + auto bad_group_index = + std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(bad_group_index)); + args.emplace_back(std::unique_ptr(new ExecContextNode())); + auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); + + RetType result; + Status st = RunGroupAgg(std::move(expr), &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("GroupAvg"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} + } // namespace jitfusion From 571673f9a2ad450da829807237e886b5b25c8155 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 16:09:56 +0800 Subject: [PATCH 03/41] revert -Rpass=loop-vectorize --- BUILD | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILD b/BUILD index 003dcb2..e38bdb3 100644 --- a/BUILD +++ b/BUILD @@ -18,7 +18,7 @@ cc_library( "-DNDEBUG", "-ftree-vectorize", #"-g", - "-Rpass=loop-vectorize", + #"-Rpass=loop-vectorize", "-DHAS_XSIMD", ], ) From 365505607f4a330a56ab78b864eca78e1846580d Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 16:10:15 +0800 Subject: [PATCH 04/41] remove useless file --- build.log | 14783 ---------------------------------------------------- 1 file changed, 14783 deletions(-) delete mode 100644 build.log diff --git a/build.log b/build.log deleted file mode 100644 index 7ec055d..0000000 --- a/build.log +++ /dev/null @@ -1,14783 +0,0 @@ -Computing main repo mapping: -Loading: -Loading: 0 packages loaded -Analyzing: target //:jitfusion_test (1 packages loaded, 0 targets configured) -Analyzing: target //:jitfusion_test (1 packages loaded, 0 targets configured) - -INFO: Analyzed target //:jitfusion_test (89 packages loaded, 7138 targets configured). -[10 / 64] Compiling test/binary_op_test.cc; 1s darwin-sandbox ... (12 actions running) -[10 / 64] Compiling test/binary_op_test.cc; 6s darwin-sandbox ... (13 actions, 12 running) -[11 / 64] Compiling test/binary_op_test.cc; 7s darwin-sandbox ... (12 actions, 11 running) -[11 / 64] Compiling test/binary_op_test.cc; 9s darwin-sandbox ... (13 actions, 12 running) -[12 / 64] Compiling test/binary_op_test.cc; 10s darwin-sandbox ... (13 actions, 12 running) -[19 / 64] Compiling test/function_test.cc; 11s darwin-sandbox ... (13 actions, 12 running) -[22 / 64] Compiling test/list_basic_test.cc; 4s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/arena.cc: -src/arena.cc:88:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 88 | free(buf); - | ^ -src/arena.cc:126:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 126 | for (auto& chunk : chunks_) { - | ^ -src/arena.cc:126:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/arena.cc:88:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 88 | free(buf); - | ^ -src/arena.cc:126:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 126 | for (auto& chunk : chunks_) { - | ^ -src/arena.cc:126:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[24 / 64] Compiling test/list_cast_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) -[25 / 64] Compiling test/list_bitwise_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/codegen/binary_op_codegen.cc: -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/binary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: -In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: -In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 2374 | for (const auto &B : Bundles) - | ^ -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -INFO: From Compiling src/codegen/codegen.cc: -In file included from src/codegen/codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[33 / 64] Compiling test/list_group_test.cc; 4s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/codegen/const_list_value_codegen.cc: -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2138:9: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 2138 | if (!value_comp()(__root->__value_, __v)) { - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1292: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:736:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 736 | return __index == __variant_npos<__index_t> ? variant_npos : __index; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1510 | if (__rhs.valueless_by_exception()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:1510:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 2137 | while (__root != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:2137:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 21 | for (std::size_t idx = 0; idx < list.size(); ++idx) { - | ^ -src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/codegen/const_list_value_codegen.cc:21:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1854: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 30 | for (; __first2 != __last2; ++__first1, (void)++__first2) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:620: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:124:14: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 124 | return __builtin_memcmp(__lhs, __rhs, __count); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1854: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 30 | for (; __first2 != __last2; ++__first1, (void)++__first2) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/lexicographical_compare.h:30:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1680:11: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1680 | if (value_comp()(__v, __nd->__value_)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:0:0 - 1773 | __tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1773 | __tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1773:36: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1679 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:1679:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1004 | } else - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 548 | while (__first1 != __last1) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 517 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/const_list_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/map:593: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 284 | while (__x != __root && !__x->__parent_unsafe()->__is_black_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__tree:284:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[35 / 64] Compiling test/list_group_test.cc; 5s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/codegen/const_value_codegen.cc: -In file included from src/codegen/const_value_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[36 / 64] Compiling test/list_group_test.cc; 6s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/codegen/entry_argument_codegen.cc: -In file included from src/codegen/entry_argument_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/entry_argument_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/entry_argument_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/entry_argument_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/codegen/function_codegen.cc: -In file included from src/codegen/function_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:308: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:265:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 265 | return __builtin_operator_new(__args...); - | ^ -In file included from src/codegen/function_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/concepts.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/format_parse_context.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:645:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 645 | __builtin_memcpy(const_cast<__remove_const_t<_Tp>*>(__result), __first, sizeof(_Tp) * (__last - __first)); - | ^ -src/codegen/function_codegen.cc:24:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 24 | for (const auto& args : args_list) { - | ^ -src/codegen/function_codegen.cc:24:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/codegen/function_codegen.cc:24:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/function_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/function_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/function_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: -In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: -In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 2374 | for (const auto &B : Bundles) - | ^ -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -INFO: From Compiling src/codegen/if_block_codegen.cc: -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 106 | for (const auto &[name, val] : info.modified) { - | ^ -src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/codegen/if_block_codegen.cc:106:34: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1077 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1076 | __u.size() = 0; - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:547: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__node_handle:65: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 633 | while (__iter != __last) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1077 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1076 | __u.size() = 0; - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:547: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__node_handle:65: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 633 | while (__iter != __last) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1805: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:27: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:325: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_bool.h:19: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_integral.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/formatter_output.h:22: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__format/parser_std_format_spec.h:39: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:27: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:27: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/codegen/if_block_codegen.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/codegen/no_op_codegen.cc: -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1077 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1076 | __u.size() = 0; - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 633 | while (__iter != __last) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/codegen/no_op_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/codegen/if_codegen.cc: -In file included from src/codegen/if_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/if_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[44 / 64] Compiling src/codegen/ref_node_codegen.cc; 3s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/diagnostic.cc: -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:265:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 265 | return __builtin_operator_new(__args...); - | ^ -src/diagnostic.cc:32:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 32 | for (size_t i = 0; i < text.size(); ++i) { - | ^ -src/diagnostic.cc:32:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:32:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:32:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:12: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1002:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1002 | __r_.first() = __str.__r_.first(); - | ^ -src/diagnostic.cc:85:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 85 | for (int ln = start_line; ln <= end_line && ln <= total_lines; ++ln) { - | ^ -src/diagnostic.cc:85:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:85:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:12: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -src/diagnostic.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 106 | for (const auto& note : notes_) { - | ^ -src/diagnostic.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:106:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:12: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -src/diagnostic.cc:109:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 109 | for (const auto& hint : hints_) { - | ^ -src/diagnostic.cc:109:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:109:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:12: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -src/diagnostic.cc:61:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 61 | for (const auto& note : notes_) { - | ^ -src/diagnostic.cc:61:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:61:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/diagnostic.cc:7: -In file included from include/diagnostic.h:12: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -src/diagnostic.cc:64:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 64 | for (const auto& hint : hints_) { - | ^ -src/diagnostic.cc:64:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/diagnostic.cc:64:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/codegen/ref_node_codegen.cc: -In file included from src/codegen/ref_node_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1380:90: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1380 | _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); } - | ^ -In file included from src/codegen/ref_node_codegen.cc:7: -In file included from src/codegen/codegen.h:12: -src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 37 | for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { - | ^ -src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/scope_stack.h:37:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/ref_node_codegen.cc:7: -In file included from src/codegen/codegen.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ - -INFO: From Compiling src/function/murmurhash3.cc: -src/function/murmurhash3.cc:95:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 95 | for (int i = -nblocks; i; i++) { - | ^ -src/function/murmurhash3.cc:95:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/murmurhash3.cc:158:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 158 | for (int i = -nblocks; i; i++) { - | ^ -src/function/murmurhash3.cc:158:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/murmurhash3.cc:313:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 313 | for (int i = 0; i < nblocks; i++) { - | ^ -src/function/murmurhash3.cc:313:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/codegen/switch_codegen.cc: -In file included from src/codegen/switch_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/switch_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:34: -external/llvm/llvm/include/llvm/IR/Instructions.h:2639:7: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 2639 | growOperands(); // Get more space! - | ^ -external/llvm/llvm/include/llvm/IR/Instructions.h:2638:29: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 2638 | if (getNumOperands() == ReservedSpace) - | ^ -src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 71 | for (const auto &[val, block] : incoming_values) { - | ^ -src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/codegen/switch_codegen.cc:71:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/switch_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/codegen/switch_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/exec_node.cc: -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 226 | } else if (__count > 0) { - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 931 | __r_.first() = __rep(); - | ^ -src/exec_node.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 106 | for (const auto& child : args_) { - | ^ -src/exec_node.cc:106:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:106:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 15 | auto cloned = CloneImpl(); - | ^ -In file included from src/exec_node.cc:7: -include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } - | ^ -src/exec_node.cc:119:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (const auto& arg : args_) { - | ^ -src/exec_node.cc:119:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:119:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:928:9: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 928 | if (__size > max_size()) - | ^ -src/exec_node.cc:127:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 127 | for (size_t i = 0; i < args_.size(); ++i) { - | ^ -src/exec_node.cc:127:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:127:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:127:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 15 | auto cloned = CloneImpl(); - | ^ -In file included from src/exec_node.cc:7: -include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } - | ^ -src/exec_node.cc:150:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 150 | for (const auto& arg : args_) { - | ^ -src/exec_node.cc:150:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:150:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 226 | } else if (__count > 0) { - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 931 | __r_.first() = __rep(); - | ^ -src/exec_node.cc:158:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 158 | for (const auto& child : args_) { - | ^ -src/exec_node.cc:158:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:158:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 15 | auto cloned = CloneImpl(); - | ^ -In file included from src/exec_node.cc:7: -include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } - | ^ -src/exec_node.cc:171:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 171 | for (const auto& arg : args_) { - | ^ -src/exec_node.cc:171:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 226 | } else if (__count > 0) { - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 931 | __r_.first() = __rep(); - | ^ -src/exec_node.cc:179:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 179 | for (const auto& child : args_) { - | ^ -src/exec_node.cc:179:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:179:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 15 | auto cloned = CloneImpl(); - | ^ -In file included from src/exec_node.cc:7: -include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } - | ^ -src/exec_node.cc:192:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 192 | for (const auto& arg : args_) { - | ^ -src/exec_node.cc:192:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:192:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:226:14: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 226 | } else if (__count > 0) { - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:931:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 931 | __r_.first() = __rep(); - | ^ -src/exec_node.cc:200:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 200 | for (const auto& child : args_) { - | ^ -src/exec_node.cc:200:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:200:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_node.cc:15:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 15 | auto cloned = CloneImpl(); - | ^ -In file included from src/exec_node.cc:7: -include/exec_node.h:47:54: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 47 | void SetLocation(const SourceLocation& loc) { loc_ = loc; } - | ^ -src/exec_node.cc:212:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 212 | for (const auto& arg : args_) { - | ^ -src/exec_node.cc:212:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:212:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | for (const auto& value : value_list) { - | ^ -src/exec_node.cc:59:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_node.cc:59:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1004 | } else - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 548 | while (__first1 != __last1) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy_move_common.h:18: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_node.cc:7: -In file included from include/exec_node.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 517 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[49 / 64] Compiling test/no_op_test.cc; 3s darwin-sandbox ... (13 actions, 12 running) -INFO: From Compiling src/codegen/unary_op_codegen.cc: -In file included from src/codegen/unary_op_codegen.cc:7: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -[52 / 64] Compiling src/exec_engine.cc; 2s darwin-sandbox ... (11 actions running) -INFO: From Compiling src/function/string_function_init.cc: -In file included from src/function/string_function_init.cc:10: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:226: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 380 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/char_traits.h:380:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/string_function_init.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/function/math_function_init.cc: -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1004 | } else - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1002:20: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1002 | __r_.first() = __str.__r_.first(); - | ^ -src/function/math_function_init.cc:431:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 431 | for (auto args_type : kTypeVec) { - | ^ -src/function/math_function_init.cc:431:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/math_function_init.cc:431:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: -In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: -In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 2374 | for (const auto &B : Bundles) - | ^ -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1004:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1004 | } else - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:549:68: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 549 | allocator_traits<_Alloc>::construct(__alloc, std::__to_address(__first2), *__first1); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 548 | while (__first1 != __last1) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:548:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:591: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/remove.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/find.h:23: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__string/constexpr_c_functions.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/function/math_function_init.cc:8: -In file included from src/codegen/codegen.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:647: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string_view:941: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 517 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:517:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/function_registry.cc: -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { - | ^ -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 81 | for (const auto& param_type : param_types_) { - | ^ -src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:13: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:317: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ostream/basic_ostream.h:619:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 619 | return std::__put_character_sequence(__os, __str, _Traits::length(__str)); - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:534: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/bind.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/tuple:1411: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/exception:81: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__exception/exception_ptr.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/function_registry.cc:92:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 92 | for (std::size_t i = 0; i < param_types_.size(); i++) { - | ^ -src/function_registry.cc:92:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:180:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 180 | auto* func = m->getFunction(sign.ToString()); - | ^ -src/function_registry.cc:176:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 176 | for (const auto& [sign, fc] : signature2funcstruct_) { - | ^ -src/function_registry.cc:176:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:176:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:176:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:200:37: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 200 | symbols.try_emplace(mangle(sign.ToString()), function_a_address, llvm::JITSymbolFlags::Exported); - | ^ -src/function_registry.cc:195:31: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 195 | for (const auto& [sign, fc] : signature2funcstruct_) { - | ^ -src/function_registry.cc:195:31: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:195:31: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:195:31: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:174:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 174 | ++S->getValue(); - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:900:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 900 | return Buckets; - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 477 | for (size_t i = 0; i < getNumBuckets(); ++i) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:477:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 181 | } - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 181 | } - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 181 | } - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 671 | while (true) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:22: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h:21: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/SymbolStringPool.h:181:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 181 | } - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 81 | for (const auto& param_type : param_types_) { - | ^ -src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { - | ^ -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 81 | for (const auto& param_type : param_types_) { - | ^ -src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { - | ^ -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:24: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/builtin_new_allocator.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:81:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 81 | for (const auto& param_type : param_types_) { - | ^ -src/function_registry.cc:81:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 69 | for (std::size_t idx = 0; idx < param_types_.size(); idx++) { - | ^ -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function_registry.cc:69:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function_registry.cc:7: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 671 | while (true) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 423 | for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B) - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:423:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 671 | while (true) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:671:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/function/list_aggregation.cc: -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] - 26 | for (std::size_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:26:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 850 | return __emplace_unique_key_args(_NodeTypes::__get_key(__x), __x); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:850:12: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1132 | for (; __first != __last; ++__first) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:1132:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_aggregation.cc:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_aggregation.cc:97:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 97 | for (; i < batch_end; i += 8) { - | ^ -src/function/list_aggregation.cc:103:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] - 103 | for (; i < a.len; i++) { - | ^ -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] - 38 | for (std::size_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 16, interleaved count: 2) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_aggregation.cc:38:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:230: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/compare:174: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/cmath:316: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__math/hypot.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/max_element.h:30:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 30 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 191 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:191:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 205 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:205:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 161 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:161:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 154 | while (__comp(*__i, *__m)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:154:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 124 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:124:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 118 | while (!__comp(*__first, *__i)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:118:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:101:11: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 35 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:35:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1823: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/adjacent_find.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/comp.h:40:20: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 40 | return __lhs < __rhs; - | ^ -In file included from src/function/list_aggregation.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1827: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/min_element.h:37:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 37 | while (++__i != __last) - | ^ -[56 / 64] Compiling src/exec_engine.cc; 4s darwin-sandbox ... (7 actions running) - -INFO: From Compiling src/function/list_group.cc: -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 39 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:39:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:39:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1268 | return __table_.__emplace_unique_key_args( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1268:21: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:58:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 58 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:58:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:58:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_group.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -src/function/list_group.cc:74:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 74 | for (uint32_t i = 0; i < group_index.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:94:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 94 | result.data[filled++] = keys.data[i]; - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:95:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 95 | } - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 92 | for (uint32_t i = 0; i < keys.len; ++i) { - | ^ -src/function/list_group.cc:92:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_group.cc:92:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:16: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:24: -In file included from external/llvm/llvm/include/llvm/IR/ConstantFolder.h:25: -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 354 | while (ArrayType *ArrTy = dyn_cast(Ty)) - | ^ -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/Operator.h:354:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:16: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_group.cc:16: -In file included from src/codegen/codegen.h:11: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:29: -In file included from external/llvm/llvm/include/llvm/IR/Constants.h:29: -In file included from external/llvm/llvm/include/llvm/IR/ConstantRange.h:35: -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 2374 | for (const auto &B : Bundles) - | ^ -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/InstrTypes.h:2374:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop -Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop -Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop -Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop -Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:38: remark: loop not vectorized: unsafe dependent memory operations in loop. Use #pragma clang loop distribute(enable) to allow loop distribution to attempt to isolate the offending operations into a separate loop -Unsafe indirect dependence. Memory location is the same as accessed at src/function/list_group.cc:115:5 [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:115:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 115 | result.data[group_index.data[i]] += values.data[i]; - | ^ -src/function/list_group.cc:114:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 114 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:135:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 135 | result.data[group_index.data[i]] = std::max(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:134:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 134 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:155:49: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 155 | result.data[group_index.data[i]] = std::min(result.data[group_index.data[i]], values.data[i]); - | ^ -src/function/list_group.cc:154:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 154 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:175:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 175 | result.data[gid] += values.data[i]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -src/function/list_group.cc:175:5: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 175 | result.data[gid] += values.data[i]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ -In file included from src/function/list_group.cc:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1437:10: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 1437 | return this->__begin_[__n]; - | ^ -src/function/list_group.cc:173:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 173 | for (uint32_t i = 0; i < values.len; ++i) { - | ^ -src/function/list_group.cc:178:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 178 | for (uint32_t g = 0; g < distinct; ++g) { - | ^ - -INFO: From Compiling src/validator.cc: -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/validator.cc:253:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 253 | JF_RETURN_NOT_OK(arg->Accept(this)); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/validator.cc:252:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 252 | for (const auto& arg : function_node.GetArgs()) { - | ^ -src/validator.cc:252:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/validator.cc:252:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/validator.cc:304:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 304 | JF_RETURN_NOT_OK(arg->Accept(this)); - | ^ -src/validator.cc:303:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 303 | for (const auto& arg : if_node.GetArgs()) { - | ^ -src/validator.cc:303:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/validator.cc:303:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/validator.cc:303:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/validator.cc:337:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 337 | JF_RETURN_NOT_OK(arg->Accept(this)); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/validator.cc:336:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 336 | for (const auto& arg : switch_node.GetArgs()) { - | ^ -src/validator.cc:336:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/validator.cc:336:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/validator.cc:347:41: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 347 | if (i + 1 != size && i % 2 == 0 && !TypeHelper::IsNumericType(switch_node.GetArgs()[i]->GetReturnType())) { - | ^ -src/validator.cc:346:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 346 | for (std::size_t i = 0; i < size; i++) { - | ^ -src/validator.cc:346:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/validator.cc:346:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/validator.cc:346:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1379 | _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1379:78: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1729 | .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1729:8: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:1380:90: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1380 | _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); } - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:12: -src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 37 | for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { - | ^ -src/scope_stack.h:37:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/scope_stack.h:37:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1077:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1077 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1076:92: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1076 | __u.size() = 0; - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 633 | while (__iter != __last) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:633:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1778:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1778 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1775 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1775:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1757:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1757 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1754 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1757:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1757 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1754 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1754:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/validator.cc:7: -In file included from src/validator.h:9: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/validator.cc:7: -In file included from src/validator.h:10: -In file included from include/exec_node.h:13: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/exec_engine.cc: -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1553 | pointer __end = this->__end_; - | ^ -src/exec_engine.cc:404:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 404 | EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) - | ^ -src/exec_engine.cc:404:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:404:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1361:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1361 | return append(__s); - | ^ -In file included from src/exec_engine.cc:7: -include/exec_engine.h:46:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 46 | for (size_t i = 0; i < errors.size(); ++i) { - | ^ -include/exec_engine.h:46:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -include/exec_engine.h:46:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1553 | pointer __end = this->__end_; - | ^ -src/exec_engine.cc:412:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 412 | EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) - | ^ -src/exec_engine.cc:412:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:412:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:448:5: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 448 | JF_RETURN_NOT_OK(validator.Validate(exec_node.get())); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_engine.cc:447:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 447 | for (const auto& exec_node : exec_nodes) { - | ^ -src/exec_engine.cc:447:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:447:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:462:50: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 462 | std::string func_name = kEntryFunctionName + std::to_string(i); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1028:9: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 1028 | : __r_([](basic_string& __s) -> decltype(__s.__r_)&& { - | ^ -src/exec_engine.cc:461:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 461 | for (size_t i = 0; i < exec_nodes.size(); ++i) { - | ^ -src/exec_engine.cc:461:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:461:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:176:36: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 176 | return lookupLinkerMangled(JD, mangle(UnmangledName)); - | ^ -src/exec_engine.cc:481:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 481 | for (size_t i = 0; i < func_names.size(); ++i) { - | ^ -src/exec_engine.cc:481:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:481:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:481:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1553 | pointer __end = this->__end_; - | ^ -src/exec_engine.cc:502:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 502 | EXPAND_SWITCH_TYPE(func_ptr, ret_type) - | ^ -src/exec_engine.cc:502:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:502:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1558:13: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 1558 | __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1553:25: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1553 | pointer __end = this->__end_; - | ^ -src/exec_engine.cc:515:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 515 | EXPAND_SWITCH_TYPE(func_ptr, ret_type) - | ^ -src/exec_engine.cc:515:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:515:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:989: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:508:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 508 | return __at(__fmatrix, __vs.index()...)(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 787 | _LIBCPP_VARIANT_DESTRUCTOR( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:553:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 553 | Status st = ExecuteAt(i, entry_arguments, &(*results)[i]); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_engine.cc:552:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 552 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - | ^ -src/exec_engine.cc:552:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:552:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:989: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/iterator:742: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:508:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 508 | return __at(__fmatrix, __vs.index()...)(std::forward<_Visitor>(__visitor), std::forward<_Vs>(__vs).__as_base()...); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 787 | _LIBCPP_VARIANT_DESTRUCTOR( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/variant:787:1: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:570:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 570 | Status st = ExecuteAt(i, exec_ctx, entry_arguments, &(*results)[i]); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_engine.cc:569:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 569 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - | ^ -src/exec_engine.cc:569:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:569:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:586:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 586 | Status st = ExecuteAt(i, entry_arguments, results); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_engine.cc:585:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 585 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - | ^ -src/exec_engine.cc:585:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:585:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:602:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 602 | Status st = ExecuteAt(i, exec_ctx, entry_arguments, results); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -src/exec_engine.cc:601:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 601 | for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - | ^ -src/exec_engine.cc:601:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:601:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:552: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/boyer_moore_searcher.h:26: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_map:591: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:16: -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:28: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) - | ^ -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) - | ^ -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:28: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) - | ^ -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:12: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) - | ^ -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 471 | while (*Ptr == nullptr || *Ptr == StringMapImpl::getTombstoneVal()) - | ^ -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/StringMap.h:471:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1212:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1212 | __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap()); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:940: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocate_at_least.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/allocator_traits.h:14: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/construct_at.h:23: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/new:274:3: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 274 | __builtin_operator_delete(__args...); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:11: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1211 | if (__is_long()) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/string:1211:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1132:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 1132 | for (pointer __pos = __tx.__pos_; __pos != __new_end; __tx.__pos_ = ++__pos) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:1132:3: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/vector:348: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__split_buffer:258:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 258 | for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__split_buffer:258:3: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/ADT/DenseMap.h:409:55: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 409 | if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) && - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:80:5: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 80 | delete __ptr; - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:21: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h:19: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/Core.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/DenseSet.h:17: -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 408 | for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) { - | ^ -external/llvm/llvm/include/llvm/ADT/DenseMap.h:408:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:389:17: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 389 | __f.__f_->__clone(__f_); - | ^ -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 298 | for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void)++__ifirst) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:298:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 447 | void SmallVectorTemplateBase::grow(size_t MinSize) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 447 | void SmallVectorTemplateBase::grow(size_t MinSize) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:447:53: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/exec_engine.cc:165:15: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 165 | if (!called_func->hasFnAttribute(kCommutative)) { - | ^ -src/exec_engine.cc:159:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 159 | for (auto& i : bb) { - | ^ -src/exec_engine.cc:159:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:159:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/exec_engine.cc:159:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:292:7: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 292 | __ptr_.second()(__tmp); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 291 | if (__tmp) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:291:9: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:14: -In file included from include/arena.h:12: -In file included from include/status.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/sstream:320: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/istream:1367: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/ostream:194: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/format:245: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/queue:273: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/deque:2614: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/functional:548: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:401:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 401 | } - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 106 | class PassBuilder { - | ^ -external/llvm/llvm/include/llvm/Passes/PassBuilder.h:106:7: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/function.h:0:0 -In file included from src/exec_engine.cc:7: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:14: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/LLJIT.h:16: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h:20: -In file included from external/llvm/llvm/include/llvm/ExecutionEngine/JITSymbol.h:28: -In file included from external/llvm/llvm/include/llvm/Support/Error.h:17: -In file included from external/llvm/llvm/include/llvm/ADT/Twine.h:12: -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 353 | while (S != E) { - | ^ -external/llvm/llvm/include/llvm/ADT/SmallVector.h:353:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Compiling src/function/list_basic.cc: -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 55 | for (std::size_t i = 0; i < b.len; ++i) { - | ^ -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:55:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:41:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 41 | for (std::size_t i = 0; i < b.len; ++i) { - | ^ -src/function/list_basic.cc:41:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:48:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 48 | for (std::size_t i = 0; i < b.len; ++i) { - | ^ -src/function/list_basic.cc:48:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:66:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 66 | for (std::size_t i = 0; i < b.len; ++i) { - | ^ -src/function/list_basic.cc:66:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:66:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:66:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:66:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:14: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 675 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:675:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 669 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:669:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 648 | while (__first < __last && !__comp(*--__last, __pivot)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:648:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 652 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:652:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 639 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:639:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 734 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:734:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 728 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:728:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 719 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:719:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 705 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:705:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 712 | while (++__first < __last && !__comp(__pivot, *__first)) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:712:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:329:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 329 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 328 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:328:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:299:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 299 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 298 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:298:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:382:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 382 | *__j = _Ops::__iter_move(__k); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 381 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:381:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:61:16: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 61 | *__start = _Ops::__iter_move(__child_i); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 59 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:59:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1288: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/atomic:596: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/aliases.h:12: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__atomic/atomic.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/operations.h:443:18: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 443 | return __x > __y; - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:45:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 45 | for (; __i != __last; ++__i) { - | ^ -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1869: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/nth_element.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:17: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sort_heap.h:15: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/pop_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:45:19: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 45 | *__last = _IterOps<_AlgPolicy>::__iter_move(__ptr); - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 44 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/push_heap.h:44:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 35 | _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __partial_sort_impl( - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/partial_sort.h:35:75: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:0:0 -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1856: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/make_heap.h:15: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 94 | while (true) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/sift_down.h:94:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:14: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:14: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:19: -In file included from external/llvm/llvm/include/llvm/IR/IRBuilder.h:34: -external/llvm/llvm/include/llvm/IR/Instructions.h:1046:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 1046 | for (Value *Index : IdxList) - | ^ -external/llvm/llvm/include/llvm/IR/Instructions.h:1046:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:14: -In file included from include/exec_engine.h:16: -In file included from include/function_registry.h:19: -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -external/llvm/llvm/include/llvm/IR/IRBuilder.h:246:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 246 | I->setMetadata(KV.first, KV.second); - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 245 | for (const auto &KV : MetadataToCopy) - | ^ -external/llvm/llvm/include/llvm/IR/IRBuilder.h:245:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 68 | return {__tx::__convert(__first, __value), errc(0)}; - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 68 | return {__tx::__convert(__first, __value), errc(0)}; - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:79: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars.h:14: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_integral.h:68:5: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 68 | return {__tx::__convert(__first, __value), errc(0)}; - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:57:12: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 57 | return __itoa::__base_10_u32(__p, __v); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:123:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 123 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:121:16: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 121 | __buffer = __itoa::__base_10_u32(__buffer, static_cast(__value / 10000000000)); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:123:3: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 123 | } - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/to_chars_base_10.h:121:16: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 121 | __buffer = __itoa::__base_10_u32(__buffer, static_cast(__value / 10000000000)); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:153:22: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), a.data[i]); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:153:22: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | auto [ptr, ec] = std::to_chars(buf, buf + sizeof(buf), a.data[i]); - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 152 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:152:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 134 | return std::__subject_seq_combinator( - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:48:3: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 48 | switch (__r.ec) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 134 | return std::__subject_seq_combinator( - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 134 | return std::__subject_seq_combinator( - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:48:3: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 48 | switch (__r.ec) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:134:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 134 | return std::__subject_seq_combinator( - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:225:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 225 | return std::__from_chars_atoi(__first, __last, __value); - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 2) [-Rpass=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:225:10: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 225 | return std::__from_chars_atoi(__first, __last, __value); - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 171 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:171:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 101 | for (; __firstit != __lastit; ++__firstit) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:101:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:16: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 165 | do { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:165:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-analysis=loop-vectorize] - 180 | for (; __first1 < __last1; ++__first1, ++__first2) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/traits.h:180:5: remark: interleaved loop (interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:8: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/charconv:76: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] - 119 | for (; __r.ptr != __last; ++__r.ptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__charconv/from_chars_integral.h:119:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 139 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_basic.cc:139:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 190 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:190:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:190:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:818:12: remark: loop not vectorized: loop contains a switch statement [-Rpass-analysis=loop-vectorize] - 818 | return __emplace_unique_key_args(__x, std::forward<_Pp>(__x)); - | ^ -src/function/list_basic.cc:206:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 206 | for (uint32_t i = 0; i < a.len; ++i) { - | ^ -src/function/list_basic.cc:206:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:206:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -src/function/list_basic.cc:206:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1136 | while (__np != nullptr) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1136:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -In file included from src/function/list_basic.cc:7: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/algorithm:1842: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/for_each.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__ranges/movable_box.h:21: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/optional:1294: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:32: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/unique_ptr.h:451:12: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 451 | return __ptr_.first()[__i]; - | ^ -In file included from src/function/list_basic.cc:13: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/unordered_set:539: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1709:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 1709 | for (size_type __i = 0; __i < __nbc; ++__i) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1717 | for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1717:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1517:13: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 1517 | if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k)) - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 1514 | for (__nd = __nd->__next_; - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized: could not determine number of loop iterations [-Rpass-analysis=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__hash_table:1514:7: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 84 | operator()(const void* __key, _Size __len) const { - | ^ -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:84:3: note: could not determine the original source location for /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:0:0 -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__functional/hash.h:108:5: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 108 | do { - | ^ -[61 / 64] Compiling src/function/list_arithmetic.cc; 5s darwin-sandbox ... (2 actions running) - -INFO: From Compiling src/function/list_arithmetic.cc: -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 31 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:53:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 53 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 77 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:77:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:99:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 99 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:105:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 105 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 123 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:123:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:145:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:151:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 151 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 169 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:169:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:191:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 191 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:197:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 197 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 215 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_arithmetic.cc:215:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:243:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 243 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 261 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:261:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:283:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 283 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:289:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 289 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 307 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:307:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:329:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 329 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:335:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 335 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 353 | for (uint32_t i = 0; i < a.len; i++) { - | ^ -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_arithmetic.cc:353:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:375:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 375 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:381:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 381 | for (std::size_t i = vec_size; i < result.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:403:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 403 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 408 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:408:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:430:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 430 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 435 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:435:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:457:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 457 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 462 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:462:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 8, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:9: -In file included from include/exec_engine.h:10: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/memory:944: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/inout_ptr.h:16: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/shared_ptr.h:31: -In file included from /opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__memory/uninitialized_algorithms.h:13: -/opt/homebrew/Cellar/llvm/19.1.7/bin/../include/c++/v1/__algorithm/copy.h:40:17: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 40 | *__result = *__first; - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 4, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:484:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 484 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 489 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -src/function/list_arithmetic.cc:489:3: remark: vectorized loop (vectorization width: 2, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:511:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 511 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:516:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 516 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:511:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 511 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:516:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 516 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:538:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 538 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:543:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 543 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:538:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 538 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:543:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 543 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:565:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 565 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:570:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 570 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:565:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 565 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:570:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 570 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:593:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 593 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:598:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 598 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -In file included from src/function/list_arithmetic.cc:16: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_arithmetic.cc:621:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 621 | for (std::size_t i = 0; i < vec_size; i += kBatchSize) { - | ^ -src/function/list_arithmetic.cc:626:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] - 626 | for (std::size_t i = vec_size; i < a.len; ++i) { - | ^ -[62 / 64] Compiling src/function/list_comparison.cc; 6s darwin-sandbox - -INFO: From Compiling src/function/list_comparison.cc: -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 31 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:31:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 45 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:45:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 59 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:59:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 73 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:73:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 87 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:87:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] - 101 | for (std::size_t i = 0; i < a.len; i++) { - | ^ -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 16, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 8, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 4, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:101:3: remark: vectorized loop (vectorization width: 2, interleaved count: 4) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:122:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 122 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:122:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:129:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 129 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:129:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_comparison.cc:138:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 138 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 145 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:145:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:170:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 170 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:170:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:177:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 177 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:177:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_comparison.cc:186:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 186 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 193 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:193:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:529:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 529 | return vld1q_u8((uint8_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:541:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 541 | return vld1q_u16((uint16_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:551:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 551 | return vld1q_u32((uint32_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:561:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 561 | return vld1q_u64((uint64_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:535:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 535 | return vld1q_s8((int8_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:546:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 546 | return vld1q_s16((int16_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:556:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 556 | return vld1q_s32((int32_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:566:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 566 | return vld1q_s64((int64_t*)src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:108: -/usr/local/include/xsimd/types/../arch/./xsimd_neon.hpp:572:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 572 | return vld1q_f32(src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:222:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 222 | for (; i < loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:222:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:229:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 229 | for (int j = 0; i + j < result.len; j++) { - | ^ -src/function/list_comparison.cc:229:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -In file included from src/function/list_comparison.cc:15: -In file included from /usr/local/include/xsimd/xsimd.hpp:62: -In file included from /usr/local/include/xsimd/types/xsimd_batch.hpp:492: -In file included from /usr/local/include/xsimd/types/../arch/xsimd_isa.hpp:112: -/usr/local/include/xsimd/types/../arch/./xsimd_neon64.hpp:153:20: remark: loop not vectorized: instruction return type cannot be vectorized [-Rpass-analysis=loop-vectorize] - 153 | return vld1q_f64(src); - | ^ -src/function/list_comparison.cc:237:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 237 | for (std::size_t j = 0; j < vec_size; j += kBatchSize) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 245 | for (std::size_t j = vec_size; j < result.len; ++j) { - | ^ -src/function/list_comparison.cc:245:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:268:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 268 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:268:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:291:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 291 | for (int j = 0; i + j < a.len; j++) { - | ^ -src/function/list_comparison.cc:291:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that vectorization is not beneficial [-Rpass-missed=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-missed=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:328:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 328 | for (; i < vec_loop_len; i += 8) { - | ^ -src/function/list_comparison.cc:328:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:351:3: remark: the cost-model indicates that interleaving is not beneficial [-Rpass-analysis=loop-vectorize] - 351 | for (int j = 0; i + j < len; j++) { - | ^ -src/function/list_comparison.cc:351:3: remark: vectorized loop (vectorization width: 16, interleaved count: 1) [-Rpass=loop-vectorize] -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized: value that could not be identified as reduction is used outside the loop [-Rpass-analysis=loop-vectorize] -src/function/list_comparison.cc:408:7: remark: loop not vectorized: cannot identify array bounds [-Rpass-analysis=loop-vectorize] - 408 | result.data[cur++] = (a.data[(i * 8) + idx]); - | ^ -src/function/list_comparison.cc:401:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] - 401 | for (std::size_t i = 0; i < full_bytes; i++) { - | ^ -src/function/list_comparison.cc:373:38: remark: loop not vectorized: control flow cannot be substituted for a select [-Rpass-analysis=loop-vectorize] - 373 | for (int mask = 0; mask < 256; mask++) { - | ^ -src/function/list_comparison.cc:381:37: remark: loop not vectorized: call instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 381 | filter_index_table[mask][idx] = -1; - | ^ -src/function/list_comparison.cc:373:3: remark: loop not vectorized: instruction cannot be vectorized [-Rpass-analysis=loop-vectorize] - 373 | for (int mask = 0; mask < 256; mask++) { - | ^ -src/function/list_comparison.cc:373:3: remark: loop not vectorized [-Rpass-missed=loop-vectorize] -INFO: From Linking jitfusion_test: -ld64.lld: warning: /usr/local/lib/libgtest.a(gtest-all.cc.o) has version 11.3.0, which is newer than target minimum of 11.0.0 -ld64.lld: warning: /usr/local/lib/libgtest_main.a(gtest_main.cc.o) has version 11.3.0, which is newer than target minimum of 11.0.0 -ld64.lld: warning: /opt/homebrew/Cellar/llvm/19.1.7/lib/libLLVM-19.dylib has version 14.0.0, which is newer than target minimum of 11.0.0 -INFO: Found 1 target... -Target //:jitfusion_test up-to-date: - bazel-bin/jitfusion_test -INFO: Elapsed time: 25.884s, Critical Path: 12.13s -INFO: 64 processes: 10 internal, 54 darwin-sandbox. -INFO: Build completed successfully, 64 total actions From 0d20a390b49f3b5ad5c6fade92b0b080972ab32b Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 16:32:28 +0800 Subject: [PATCH 05/41] optimize FilterByBitmap function --- athena/test/pipeline_test.cc | 4 +- benchmark/bench_list_compare.cc | 33 +++++--------- doc/function.md | 20 ++++----- src/function/list_comparison.cc | 77 +++++++++++++++++++++++++++++++++ test/list_misc_test.cc | 63 +++++++++++++++++++++++++-- 5 files changed, 158 insertions(+), 39 deletions(-) diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index c23a547..d66e2ee 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -75,7 +75,7 @@ TEST(FilterTest, Test1) { std::string code = R"( a = load(entry_arg, 0); b = GenLargeBitmap(a, 3, exec_ctx); - FilterByBitmap(a, b, CountBits(b), exec_ctx); + FilterByBitmap(a, b, exec_ctx); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -95,7 +95,7 @@ TEST(FilterTest, Test2) { a = load(entry_arg, 0); b = load(entry_arg, 1); c = GenLargeBitmap(a, b, exec_ctx); - FilterByBitmap(a, c, CountBits(c), exec_ctx); + FilterByBitmap(a, c, exec_ctx); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/benchmark/bench_list_compare.cc b/benchmark/bench_list_compare.cc index ce6febf..e1c702d 100644 --- a/benchmark/bench_list_compare.cc +++ b/benchmark/bench_list_compare.cc @@ -4,16 +4,16 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeListIfSelectCall; -using ::jitfusion::bench::MakeListScalarCtxCall; -using ::jitfusion::bench::MakeRegistry; using ::jitfusion::ConstantListValueNode; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecContext; using ::jitfusion::ExecNode; using ::jitfusion::FunctionNode; using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListIfSelectCall; +using ::jitfusion::bench::MakeListScalarCtxCall; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // J. List comparison / bitmap kernels @@ -111,38 +111,25 @@ void BM_Execute_IfByBitmap(benchmark::State& state) { } BENCHMARK(BM_Execute_IfByBitmap)->Arg(4096); -// FilterByBitmap(value_list, packed_bitmap, popcount, ctx). +// FilterByBitmap(value_list, packed_bitmap, ctx) — sugar form. // -// NOTE: unlike IfByBitmap (whose U8List is a per-element 0/1 array), here the -// bitmap is a *packed* bitmap — each byte encodes 8 elements (LSB = first -// element). So its length must be exactly ceil(values.size() / 8), and -// `popcnt` is the number of 1-bits across all bytes. Using a per-element -// bitmap triggers "bitmap len is not corresponding to list len" at runtime. -// Using 0x55 (0b01010101) gives 4 ones per byte → every other element kept. +// The `packed_bitmap` is ceil(values.size() / 8) bytes; each byte encodes 8 +// elements (LSB = first element). 0x55 (0b01010101) gives 4 ones per byte → +// every other element is kept. The 3-arg sugar auto-derives `bits_cnt` via +// CountBits(bitmap) at codegen time, so we no longer have to precompute and +// pass the popcount explicitly (and can no longer get it wrong). void BM_Execute_FilterByBitmap(benchmark::State& state) { const int len = static_cast(state.range(0)); const int bitmap_bytes = (len + 7) / 8; auto reg = MakeRegistry(); std::vector values(len); std::vector bitmap(bitmap_bytes, static_cast(0x55)); - uint32_t popcnt = 0; for (int i = 0; i < len; ++i) { values[i] = i; } - // Count set bits per byte. This runs once during benchmark setup, not in - // the timed loop, so a plain portable loop is fine — no need for - // __builtin_popcount / std::popcount. - for (int b = 0; b < bitmap_bytes; ++b) { - uint8_t byte = bitmap[b]; - while (byte != 0) { - popcnt += static_cast(byte & 1U); - byte = static_cast(byte >> 1); - } - } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(bitmap))); - args.emplace_back(new ConstantValueNode(popcnt)); args.emplace_back(new jitfusion::ExecContextNode()); std::unique_ptr node(new FunctionNode("FilterByBitmap", std::move(args))); diff --git a/doc/function.md b/doc/function.md index 7a007e1..a0b064c 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1076,16 +1076,16 @@ Return a bitmap representing the results of not equal comparisons for each eleme ## FilterByBitmap Return a new list by filtering out the corresponding elements based on the bitmap. - u8list FilterByBitmap(u8list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - u16list FilterByBitmap(u16list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - u32list FilterByBitmap(u32list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - u64list FilterByBitmap(u64list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - i8list FilterByBitmap(i8list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - i16list FilterByBitmap(i16list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - i32list FilterByBitmap(i32list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - i64list FilterByBitmap(i64list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - f32list FilterByBitmap(f32list src, u8list bitmap, u32 bits_count, ptr exec_ctx) - f64list FilterByBitmap(f64list src, u8list bitmap, u32 bits_count, ptr exec_ctx) + u8list FilterByBitmap(u8list src, u8list bitmap, ptr exec_ctx) + u16list FilterByBitmap(u16list src, u8list bitmap, ptr exec_ctx) + u32list FilterByBitmap(u32list src, u8list bitmap, ptr exec_ctx) + u64list FilterByBitmap(u64list src, u8list bitmap, ptr exec_ctx) + i8list FilterByBitmap(i8list src, u8list bitmap, ptr exec_ctx) + i16list FilterByBitmap(i16list src, u8list bitmap, ptr exec_ctx) + i32list FilterByBitmap(i32list src, u8list bitmap, ptr exec_ctx) + i64list FilterByBitmap(i64list src, u8list bitmap, ptr exec_ctx) + f32list FilterByBitmap(f32list src, u8list bitmap, ptr exec_ctx) + f64list FilterByBitmap(f64list src, u8list bitmap, ptr exec_ctx) ## CountBits Count the number of 1s in the bitmap. diff --git a/src/function/list_comparison.cc b/src/function/list_comparison.cc index 78f0148..97c8e6d 100644 --- a/src/function/list_comparison.cc +++ b/src/function/list_comparison.cc @@ -5,9 +5,12 @@ * @Last Modified time: 2026-04-03 14:31:05 */ #include +#include "codegen/codegen.h" #include "exec_engine.h" #include "function_init.h" #include "function_registry.h" +#include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/Type.h" #include "status.h" #include "type.h" @@ -1364,6 +1367,79 @@ Status InitFilterByBitmapFunc(FunctionRegistry *reg) { return Status::OK(); } +llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::vector &arg_llvm_type_list, + const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { + auto *list_value = arg_llvm_value_list.at(0); + auto *bitmap_value = arg_llvm_value_list.at(1); + auto *exec_context_value = arg_llvm_value_list.at(2); + auto *list_llvm_type = arg_llvm_type_list.at(0); + + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + auto *u8list_llvm_type = ctx.complex_type.u8list_type; + + // CountBits(bitmap) -> u32 + FunctionSignature count_bits_sign("CountBits", {ValueType::kU8List}, ValueType::kU32); + auto *count_bits_func_type = llvm::FunctionType::get(i32_ty, {u8list_llvm_type}, false); + llvm::FunctionCallee count_bits_callee = + ctx.module.getOrInsertFunction(count_bits_sign.ToString(), count_bits_func_type); + llvm::Value *bits_cnt_value = ctx.builder.CreateCall(count_bits_callee, {bitmap_value}, "bits_cnt"); + + // FilterByBitmap(list, bitmap, bits_cnt, ctx) -> + FunctionSignature filter_sign("FilterByBitmap", + {sign.GetParamTypes().at(0), ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + sign.GetRetType()); + auto *filter_func_type = + llvm::FunctionType::get(list_llvm_type, {list_llvm_type, u8list_llvm_type, i32_ty, ptr_ty}, false); + llvm::FunctionCallee filter_callee = ctx.module.getOrInsertFunction(filter_sign.ToString(), filter_func_type); + return ctx.builder.CreateCall(filter_callee, {list_value, bitmap_value, bits_cnt_value, exec_context_value}, + "filter_by_bitmap"); +} + +Status InitFilterByBitmapSugarFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kU8List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kU16List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kU32List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kU64List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kI8List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kI16List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kI32List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kI64List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kF32List), + EmitFilterByBitmapSugar)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kF64List), + EmitFilterByBitmapSugar)); + return Status::OK(); +} + Status InitIfFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitIfLargeFunc(reg)); JF_RETURN_NOT_OK(InitIfLargeEqualFunc(reg)); @@ -1391,6 +1467,7 @@ Status InitFilterFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitGenNotEqualBitmapFunc(reg)); JF_RETURN_NOT_OK(InitGenNotEqualBitmapListFunc(reg)); JF_RETURN_NOT_OK(InitFilterByBitmapFunc(reg)); + JF_RETURN_NOT_OK(InitFilterByBitmapSugarFunc(reg)); return Status::OK(); } diff --git a/test/list_misc_test.cc b/test/list_misc_test.cc index f2cd6f8..5b4b3bc 100644 --- a/test/list_misc_test.cc +++ b/test/list_misc_test.cc @@ -20,12 +20,10 @@ TEST(FunctionTest, FilterByBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto bits_cnt_node = std::unique_ptr(new ConstantValueNode(12U)); auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(bits_cnt_node)); args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; @@ -45,12 +43,10 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto bits_cnt_node = std::unique_ptr(new ConstantValueNode(12U)); auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(bits_cnt_node)); args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; @@ -62,6 +58,65 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_EQ(std::get>(result), expect); } +// Keep one test exercising the 4-arg explicit-bits_cnt kernel directly, so the +// underlying kernel (and its validation logic) stays under coverage even after +// the 3-arg sugar became the recommended path. +TEST(FunctionTest, FilterByBitmapExplicitBitsCntTest) { + std::vector data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, + 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}; + std::vector bitmap = {0xFF, 0x1, 0x2, 0x5}; + std::unique_ptr func_registry; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + auto args_node = std::unique_ptr(new ConstantListValueNode(data)); + auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); + auto bits_cnt_node = std::unique_ptr(new ConstantValueNode(12U)); + auto exec_node = std::unique_ptr(new ExecContextNode()); + std::vector> args_list; + args_list.emplace_back(std::move(args_node)); + args_list.emplace_back(std::move(bitmap_node)); + args_list.emplace_back(std::move(bits_cnt_node)); + args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); + ExecEngine exec_engine; + auto st = exec_engine.Compile(op_node, func_registry); + ASSERT_TRUE(st.ok()); + RetType result; + EXPECT_TRUE(exec_engine.Execute(nullptr, &result).ok()); + std::vector expect = {1, 2, 3, 4, 5, 6, 7, 8, 9, 18, 25, 27}; + EXPECT_EQ(std::get>(result), expect); +} + +// Sugar form where the bitmap comes from another function call (GenLargeBitmap) +// rather than a constant. Ensures that `CountBits` is emitted correctly over a +// non-constant bitmap SSA value and that CSE doesn't break semantics. +TEST(FunctionTest, FilterByBitmapSugarFromGenBitmapTest) { + std::vector data = {0, 1, 2, 3, 4, 0, 1, 4, 9, 16}; + std::unique_ptr func_registry; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + + // bitmap = GenLargeBitmap(data, 3, exec_ctx) -> keep elements > 3 + std::vector> gen_args; + gen_args.emplace_back(new ConstantListValueNode(data)); + gen_args.emplace_back(new ConstantValueNode(static_cast(3))); + gen_args.emplace_back(new ExecContextNode()); + auto bitmap_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(gen_args))); + + // FilterByBitmap(data, bitmap, exec_ctx) -- sugar, no bits_cnt. + std::vector> filter_args; + filter_args.emplace_back(new ConstantListValueNode(data)); + filter_args.emplace_back(std::move(bitmap_node)); + filter_args.emplace_back(new ExecContextNode()); + auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(filter_args))); + + ExecEngine exec_engine; + auto st = exec_engine.Compile(op_node, func_registry); + ASSERT_TRUE(st.ok()); + RetType result; + EXPECT_TRUE(exec_engine.Execute(nullptr, &result).ok()); + std::vector expect = {4, 4, 9, 16}; + EXPECT_EQ(std::get>(result), expect); +} + TEST(FunctionTest, MurmurHash3X8632Test1) { std::vector data = {1000, 2000, 3000, 4000}; std::unique_ptr func_registry; From 1fb46f0db25843d7de89e28138fc520b9c6cc962 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 30 Apr 2026 16:35:38 +0800 Subject: [PATCH 06/41] fix cmake build engine_benchmark --- CMakeLists.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/CMakeLists.txt b/CMakeLists.txt index cbbccf6..94b6a32 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -198,6 +198,7 @@ if(BUILD_BENCHMARK) find_package(benchmark REQUIRED) file(GLOB ENGINE_BENCHMARK_SRC "benchmark/*.cc" "benchmark/*.h") add_executable(engine_benchmark ${ENGINE_BENCHMARK_SRC}) + target_include_directories(engine_benchmark PRIVATE ${CMAKE_SOURCE_DIR}) target_link_libraries(engine_benchmark jitfusion benchmark::benchmark) if(CMAKE_BUILD_TYPE STREQUAL "Debug") From dbfc16b73f4ee7d93056c4dd8e36ec7ad7e1d804 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 12:48:50 +0800 Subject: [PATCH 07/41] add ListLookup, ListCompactPositions, ListCompactIndex, ListGather function --- BUILD | 2 +- benchmark/bench_list_indexing.cc | 164 ++++++++++++++ doc/function.md | 50 ++++- src/function/function_init.h | 2 + src/function/list_indexing.cc | 238 ++++++++++++++++++++ test/list_indexing_test.cc | 362 +++++++++++++++++++++++++++++++ 6 files changed, 816 insertions(+), 2 deletions(-) create mode 100644 benchmark/bench_list_indexing.cc create mode 100644 src/function/list_indexing.cc create mode 100644 test/list_indexing_test.cc diff --git a/BUILD b/BUILD index e38bdb3..003dcb2 100644 --- a/BUILD +++ b/BUILD @@ -18,7 +18,7 @@ cc_library( "-DNDEBUG", "-ftree-vectorize", #"-g", - #"-Rpass=loop-vectorize", + "-Rpass=loop-vectorize", "-DHAS_XSIMD", ], ) diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc new file mode 100644 index 0000000..3f1fe4e --- /dev/null +++ b/benchmark/bench_list_indexing.cc @@ -0,0 +1,164 @@ +// K. List indexing kernels: lookup / compact / gather. +// +// Kernel overview: +// ListLookupIndex(a, b, ctx) : for each element in a, find its first +// occurrence in b, return the position +// (u32max on miss). Built on a hash +// table over b. +// ListCompactPositions(raw, ctx) : given a U32 list produced by +// ListLookupIndex, return the positions +// in `a` that hit (i.e. the indices +// themselves, filtered by "not miss"). +// ListCompactIndex(raw, ctx) : same filter, but returns the looked-up +// b-side indices directly. +// ListGather(values, idx, dflt, ctx) : out[k] = (idx[k] < values.len) ? +// values[idx[k]] : dflt. The typical +// join-realign kernel. + +#include +#include +#include +#include +#include + +#include "benchmark/bench_common.h" + +namespace { + +using ::jitfusion::ConstantListValueNode; +using ::jitfusion::ConstantValueNode; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::FunctionNode; +using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeRegistry; + +// Build `ListLookupIndex(a, b, ctx)` where both are i64 lists of length `len`. +// Half of a's keys hit in b (pattern chosen to exercise both hit and miss +// branches of the inner loop). +std::unique_ptr MakeLookupIndexCall(int len) { + std::vector a; + std::vector b; + a.reserve(len); + b.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back(i); // keys 0..len-1 + b.push_back(i * 2); // keys 0,2,4,... — only even keys from a will hit + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantListValueNode(std::move(b))); + args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode("ListLookupIndex", std::move(args))); +} + +void BM_Execute_ListLookupIndex(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + auto engine = CompileOrDie(MakeLookupIndexCall(len), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListLookupIndex)->Arg(256)->Arg(4096); + +// Build a raw U32 list that alternates between a hit (some valid index) and +// a miss (u32max) — matches the expected shape of a ListLookupIndex output and +// lets the compact kernel do real work. +std::unique_ptr MakeRawLookupList(int len) { + std::vector raw; + raw.reserve(len); + constexpr uint32_t kMiss = std::numeric_limits::max(); + for (int i = 0; i < len; ++i) { + raw.push_back((i & 1) == 0 ? static_cast(i / 2) : kMiss); + } + return std::unique_ptr(new ConstantListValueNode(std::move(raw))); +} + +void BM_Execute_ListCompactPositions(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector> args; + args.emplace_back(MakeRawLookupList(len)); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactPositions", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListCompactPositions)->Arg(256)->Arg(4096); + +void BM_Execute_ListCompactIndex(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector> args; + args.emplace_back(MakeRawLookupList(len)); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactIndex", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListCompactIndex)->Arg(256)->Arg(4096); + +// ListGather(values, idx, default, ctx). `idx` is arranged so +// every lookup hits (j < values.len) — the common hot path. +void BM_Execute_ListGather(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector values; + std::vector idx; + values.reserve(len); + idx.reserve(len); + for (int i = 0; i < len; ++i) { + values.push_back(i * 10); + idx.push_back(static_cast(len - 1 - i)); // reverse permutation + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantListValueNode(std::move(idx))); + args.emplace_back(new ConstantValueNode(static_cast(-1))); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListGather", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ListGather)->Arg(256)->Arg(4096); + +} // namespace diff --git a/doc/function.md b/doc/function.md index a0b064c..f9a8a08 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1352,4 +1352,52 @@ Numeric list to string list conversion: stringlist CastStringList(u64list src, ptr exec_ctx) stringlist CastStringList(i64list src, ptr exec_ctx) stringlist CastStringList(f32list src, ptr exec_ctx) - stringlist CastStringList(f64list src, ptr exec_ctx) \ No newline at end of file + stringlist CastStringList(f64list src, ptr exec_ctx) + +## ListLookupIndex +Given two lists `a` and `b` of the same element type, for each element in `a` return the position of its first occurrence in `b`. When an element of `a` is not found in `b`, the result entry is set to `u32max` (`std::numeric_limits::max()`) as a miss sentinel. Internally a hash table over `b` is built, so the per-element lookup is amortised O(1). + +The output length always equals `a.len`. + + u32list ListLookupIndex(u8list a, u8list b, ptr exec_ctx) + u32list ListLookupIndex(i8list a, i8list b, ptr exec_ctx) + u32list ListLookupIndex(u16list a, u16list b, ptr exec_ctx) + u32list ListLookupIndex(i16list a, i16list b, ptr exec_ctx) + u32list ListLookupIndex(u32list a, u32list b, ptr exec_ctx) + u32list ListLookupIndex(i32list a, i32list b, ptr exec_ctx) + u32list ListLookupIndex(u64list a, u64list b, ptr exec_ctx) + u32list ListLookupIndex(i64list a, i64list b, ptr exec_ctx) + u32list ListLookupIndex(f32list a, f32list b, ptr exec_ctx) + u32list ListLookupIndex(f64list a, f64list b, ptr exec_ctx) + u32list ListLookupIndex(stringlist a, stringlist b, ptr exec_ctx) + +## ListCompactPositions +Takes a `u32list` produced by `ListLookupIndex` and returns the positions in `a` that hit (i.e. the indices in the raw list whose value is **not** the miss sentinel `u32max`). Useful for building the filtered a-side of a join. + +Output length equals the number of hits; preserves the original order. + + u32list ListCompactPositions(u32list raw, ptr exec_ctx) + +## ListCompactIndex +Takes a `u32list` produced by `ListLookupIndex` and returns the looked-up b-side indices themselves, skipping miss entries. Useful for directly gathering a b-side column aligned to the hit subset of a. + +Output length equals the number of hits; preserves the original order. + + u32list ListCompactIndex(u32list raw, ptr exec_ctx) + +## ListGather +Element-wise gather from a `values` list using a `u32list` of positions. For each `k`, if `idx[k] < values.len` the output is `values[idx[k]]`, otherwise it is the supplied `default_value`. This is the typical "realign a b-side column to the a-side shape" kernel of a join. + +The output length always equals `idx.len`. + + u8list ListGather(u8list values, u32list idx, u8 default_value, ptr exec_ctx) + i8list ListGather(i8list values, u32list idx, i8 default_value, ptr exec_ctx) + u16list ListGather(u16list values, u32list idx, u16 default_value, ptr exec_ctx) + i16list ListGather(i16list values, u32list idx, i16 default_value, ptr exec_ctx) + u32list ListGather(u32list values, u32list idx, u32 default_value, ptr exec_ctx) + i32list ListGather(i32list values, u32list idx, i32 default_value, ptr exec_ctx) + u64list ListGather(u64list values, u32list idx, u64 default_value, ptr exec_ctx) + i64list ListGather(i64list values, u32list idx, i64 default_value, ptr exec_ctx) + f32list ListGather(f32list values, u32list idx, f32 default_value, ptr exec_ctx) + f64list ListGather(f64list values, u32list idx, f64 default_value, ptr exec_ctx) + stringlist ListGather(stringlist values, u32list idx, string default_value, ptr exec_ctx) diff --git a/src/function/function_init.h b/src/function/function_init.h index eeadbaa..9a6ce8b 100644 --- a/src/function/function_init.h +++ b/src/function/function_init.h @@ -14,6 +14,7 @@ Status InitListComparisonFunc(FunctionRegistry *reg); Status InitListAggregationFunc(FunctionRegistry *reg); Status InitListBasicFunc(FunctionRegistry *reg); Status InitListGroupFunc(FunctionRegistry *reg); +Status InitListIndexingFunc(FunctionRegistry *reg); Status InitMathInternalFunc(FunctionRegistry *reg); Status InitStringInternalFunc(FunctionRegistry *reg); @@ -23,6 +24,7 @@ inline Status InitListInternalFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitListAggregationFunc(reg)); JF_RETURN_NOT_OK(InitListBasicFunc(reg)); JF_RETURN_NOT_OK(InitListGroupFunc(reg)); + JF_RETURN_NOT_OK(InitListIndexingFunc(reg)); return Status::OK(); } diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc new file mode 100644 index 0000000..9f49053 --- /dev/null +++ b/src/function/list_indexing.cc @@ -0,0 +1,238 @@ +/* + * @Author: victorika + * @Date: 2026-05-06 11:15:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-06 11:15:00 + */ +#include +#include +#include +#include + +#include "exec_engine.h" +#include "function_init.h" +#include "function_registry.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +namespace { + +constexpr uint32_t kLookupMiss = std::numeric_limits::max(); + +template +U32ListStruct ListLookupIndex(KList a, KList b, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + U32ListStruct result; + result.len = a.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * a.len)); + + std::unordered_map table; + table.reserve(static_cast(b.len) * 2); + for (uint32_t j = 0; j < b.len; ++j) { + table.try_emplace(b.data[j], j); + } + + for (uint32_t i = 0; i < a.len; ++i) { + auto it = table.find(a.data[i]); + result.data[i] = (it == table.end()) ? kLookupMiss : it->second; + } + return result; +} + +U32ListStruct ListLookupIndexString(StringListStruct a, StringListStruct b, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + U32ListStruct result; + result.len = a.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * a.len)); + + std::unordered_map table; + table.reserve(static_cast(b.len) * 2); + for (uint32_t j = 0; j < b.len; ++j) { + std::string_view sv(b.data[j].data, b.data[j].len); + table.try_emplace(sv, j); + } + + for (uint32_t i = 0; i < a.len; ++i) { + std::string_view sv(a.data[i].data, a.data[i].len); + auto it = table.find(sv); + result.data[i] = (it == table.end()) ? kLookupMiss : it->second; + } + return result; +} + +U32ListStruct ListCompactPositions(U32ListStruct raw, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + uint32_t hits = 0; + for (uint32_t i = 0; i < raw.len; ++i) { + hits += (raw.data[i] != kLookupMiss) ? 1U : 0U; + } + + U32ListStruct result; + result.len = hits; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * hits)); + + uint32_t out = 0; + for (uint32_t i = 0; i < raw.len; ++i) { + if (raw.data[i] != kLookupMiss) { + result.data[out++] = i; + } + } + return result; +} + +U32ListStruct ListCompactIndex(U32ListStruct raw, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + + uint32_t hits = 0; + for (uint32_t i = 0; i < raw.len; ++i) { + hits += (raw.data[i] != kLookupMiss) ? 1U : 0U; + } + + U32ListStruct result; + result.len = hits; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * hits)); + + uint32_t out = 0; + for (uint32_t i = 0; i < raw.len; ++i) { + if (raw.data[i] != kLookupMiss) { + result.data[out++] = raw.data[i]; + } + } + return result; +} + +template +VList ListGather(VList values, U32ListStruct idx, typename VList::CElementType default_value, void *exec_context) { + using V = typename VList::CElementType; + auto *exec_ctx = reinterpret_cast(exec_context); + VList result; + result.len = idx.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(V) * idx.len)); + + for (uint32_t k = 0; k < idx.len; ++k) { + uint32_t j = idx.data[k]; + result.data[k] = (j < values.len) ? values.data[j] : default_value; + } + return result; +} + +Status InitListLookupIndexFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListLookupIndex", {ValueType::kStringList, ValueType::kStringList, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListLookupIndexString))); + return Status::OK(); +} + +Status InitListCompactFuncs(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListCompactPositions", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(ListCompactPositions))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListCompactIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(ListCompactIndex))); + return Status::OK(); +} + +Status InitListGatherFunc(FunctionRegistry *reg) { + // Signature: ListGather(values, idx, default, ctx) + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kU8List, ValueType::kU32List, ValueType::kU8, ValueType::kPtr}, + ValueType::kU8List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kI8List, ValueType::kU32List, ValueType::kI8, ValueType::kPtr}, + ValueType::kI8List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kU16List, ValueType::kU32List, ValueType::kU16, ValueType::kPtr}, + ValueType::kU16List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kI16List, ValueType::kU32List, ValueType::kI16, ValueType::kPtr}, + ValueType::kI16List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + ValueType::kU32List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kI32List, ValueType::kU32List, ValueType::kI32, ValueType::kPtr}, + ValueType::kI32List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kU64List, ValueType::kU32List, ValueType::kU64, ValueType::kPtr}, + ValueType::kU64List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kI64List, ValueType::kU32List, ValueType::kI64, ValueType::kPtr}, + ValueType::kI64List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kF32List, ValueType::kU32List, ValueType::kF32, ValueType::kPtr}, + ValueType::kF32List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", {ValueType::kF64List, ValueType::kU32List, ValueType::kF64, ValueType::kPtr}, + ValueType::kF64List), + reinterpret_cast(ListGather))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ListGather", + {ValueType::kStringList, ValueType::kU32List, ValueType::kString, ValueType::kPtr}, + ValueType::kStringList), + reinterpret_cast(ListGather))); + return Status::OK(); +} + +} // namespace + +Status InitListIndexingFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(InitListLookupIndexFunc(reg)); + JF_RETURN_NOT_OK(InitListCompactFuncs(reg)); + JF_RETURN_NOT_OK(InitListGatherFunc(reg)); + return Status::OK(); +} + +} // namespace jitfusion diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc new file mode 100644 index 0000000..bea2341 --- /dev/null +++ b/test/list_indexing_test.cc @@ -0,0 +1,362 @@ +/* + * @Author: victorika + * @Date: 2026-05-06 11:20:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-06 11:20:00 + */ +#include +#include +#include +#include +#include + +#include "exec_engine.h" +#include "exec_node.h" +#include "function_registry.h" +#include "gtest/gtest.h" +#include "status.h" +#include "type.h" + +using namespace jitfusion; + +namespace { + +constexpr uint32_t kMiss = std::numeric_limits::max(); + +// Build a FunctionNode that takes two lists and an ExecContextNode. +std::unique_ptr MakeLookup(std::unique_ptr a, std::unique_ptr b) { + std::vector> args; + args.emplace_back(std::move(a)); + args.emplace_back(std::move(b)); + args.emplace_back(std::make_unique()); + return std::make_unique("ListLookupIndex", std::move(args)); +} + +std::unique_ptr MakeCompactPositions(std::unique_ptr raw) { + std::vector> args; + args.emplace_back(std::move(raw)); + args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactPositions", std::move(args)); +} + +std::unique_ptr MakeCompactIndex(std::unique_ptr raw) { + std::vector> args; + args.emplace_back(std::move(raw)); + args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactIndex", std::move(args)); +} + +std::unique_ptr MakeGather(std::unique_ptr values, std::unique_ptr idx, + std::unique_ptr default_value) { + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(idx)); + args.emplace_back(std::move(default_value)); + args.emplace_back(std::make_unique()); + return std::make_unique("ListGather", std::move(args)); +} + +RetType RunExpr(std::unique_ptr root, Status *status_out = nullptr) { + std::unique_ptr func_registry; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + ExecEngine engine; + EXPECT_TRUE(engine.Compile(root, func_registry).ok()); + RetType result; + Status st = engine.Execute(nullptr, &result); + if (status_out != nullptr) { + *status_out = std::move(st); + } else { + EXPECT_TRUE(st.ok()); + } + return result; +} + +} // namespace + +TEST(ListIndexingTest, LookupIndexI32Basic) { + std::vector a = {10, 20, 30, 40}; + std::vector b = {30, 10, 99}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {1, kMiss, 0, kMiss}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexI32AllHit) { + std::vector a = {1, 2, 3}; + std::vector b = {3, 2, 1}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {2, 1, 0}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexI32AllMiss) { + std::vector a = {1, 2, 3}; + std::vector b = {4, 5, 6}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {kMiss, kMiss, kMiss}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexI32EmptyA) { + std::vector a = {}; + std::vector b = {1, 2}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListIndexingTest, LookupIndexI32EmptyB) { + std::vector a = {1, 2}; + std::vector b = {}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {kMiss, kMiss}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexI32DuplicateBEarliestWins) { + std::vector a = {7, 8}; + std::vector b = {7, 7, 8, 8}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {0, 2}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexU64) { + std::vector a = {100, 200, 300}; + std::vector b = {200, 300}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {kMiss, 0, 1}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexF64) { + std::vector a = {1.5, 2.5, 3.5}; + std::vector b = {3.5, 1.5}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {1, kMiss, 0}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, LookupIndexString) { + std::vector a = {"alice", "bob", "carol", "dave"}; + std::vector b = {"carol", "alice"}; + auto node = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto result = RunExpr(std::move(node)); + std::vector expect = {1, kMiss, 0, kMiss}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, CompactPositionsBasic) { + // raw = [3, MAX, 0, MAX, 2] -> positions = [0, 2, 4] + std::vector raw = {3, kMiss, 0, kMiss, 2}; + auto node = MakeCompactPositions(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + std::vector expect = {0, 2, 4}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, CompactPositionsNoMiss) { + std::vector raw = {5, 3, 2}; + auto node = MakeCompactPositions(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + std::vector expect = {0, 1, 2}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, CompactPositionsAllMiss) { + std::vector raw = {kMiss, kMiss, kMiss}; + auto node = MakeCompactPositions(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListIndexingTest, CompactPositionsEmpty) { + std::vector raw = {}; + auto node = MakeCompactPositions(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + EXPECT_TRUE(std::get>(result).empty()); +} + +TEST(ListIndexingTest, CompactIndexBasic) { + // raw = [3, MAX, 0, MAX, 2] -> compact_idx = [3, 0, 2] + std::vector raw = {3, kMiss, 0, kMiss, 2}; + auto node = MakeCompactIndex(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + std::vector expect = {3, 0, 2}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, CompactIndexNoMiss) { + std::vector raw = {5, 3, 2}; + auto node = MakeCompactIndex(std::make_unique(raw)); + auto result = RunExpr(std::move(node)); + std::vector expect = {5, 3, 2}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, GatherI32WithDefault) { + // values = [100, 200, 300] + // idx = [2, MAX, 0, 1, MAX] + // out = [300, -1, 100, 200, -1] + std::vector values = {100, 200, 300}; + std::vector idx = {2, kMiss, 0, 1, kMiss}; + auto node = MakeGather(std::make_unique(values), std::make_unique(idx), + std::make_unique(static_cast(-1))); + auto result = RunExpr(std::move(node)); + std::vector expect = {300, -1, 100, 200, -1}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, GatherF64WithDefault) { + std::vector values = {1.1, 2.2, 3.3}; + std::vector idx = {kMiss, 2, 0}; + auto node = MakeGather(std::make_unique(values), std::make_unique(idx), + std::make_unique((-9.9))); + auto result = RunExpr(std::move(node)); + std::vector expect = {-9.9, 3.3, 1.1}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, GatherStringWithDefault) { + std::vector values = {"foo", "bar", "baz"}; + std::vector idx = {1, kMiss, 0}; + auto node = MakeGather(std::make_unique(values), std::make_unique(idx), + std::make_unique(std::string(""))); + auto result = RunExpr(std::move(node)); + std::vector expect = {"bar", "", "foo"}; + EXPECT_EQ(std::get>(result), expect); +} + +TEST(ListIndexingTest, GatherEmptyIdx) { + std::vector values = {1, 2, 3}; + std::vector idx = {}; + auto node = MakeGather(std::make_unique(values), std::make_unique(idx), + std::make_unique(static_cast(0))); + auto result = RunExpr(std::move(node)); + EXPECT_TRUE(std::get>(result).empty()); +} + +// ----------------------------------------------------------------------------- +// End-to-end join scenarios mirroring the motivating use case: +// a (keys) - c (a-side value) // one-to-one +// b (keys) - d1, d2 (b-side values) // one-to-one +// "Join on key, return d1/d2 aligned to a". +// ----------------------------------------------------------------------------- + +TEST(ListIndexingTest, E2EJoinWithDefaultTwoValueColumns) { + // a = [10, 20, 30, 40] (key) + // b = [30, 10, 99] (key) + // d1 aligned to b: [300, 100, 999] + // d2 aligned to b: ["c30", "c10", "c99"] + // Expected, aligned to a with defaults: + // d1' = [100, 0, 300, 0] + // d2' = ["c10", "NA", "c30", "NA"] + std::vector a = {10, 20, 30, 40}; + std::vector b = {30, 10, 99}; + std::vector d1 = {300, 100, 999}; + std::vector d2 = {"c30", "c10", "c99"}; + + // raw = ListLookupIndex(a, b) + auto raw_node = MakeLookup(std::make_unique(a), std::make_unique(b)); + // ListGather(d1, raw, 0) + auto gather_d1 = MakeGather(std::make_unique(d1), std::move(raw_node), + std::make_unique(static_cast(0))); + auto r1 = RunExpr(std::move(gather_d1)); + std::vector expect_d1 = {100, 0, 300, 0}; + EXPECT_EQ(std::get>(r1), expect_d1); + + // Redo the lookup (CSE would merge in real expressions; tests run each tree + // standalone). + auto raw_node2 = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto gather_d2 = MakeGather(std::make_unique(d2), std::move(raw_node2), + std::make_unique(std::string("NA"))); + auto r2 = RunExpr(std::move(gather_d2)); + std::vector expect_d2 = {"c10", "NA", "c30", "NA"}; + EXPECT_EQ(std::get>(r2), expect_d2); +} + +TEST(ListIndexingTest, E2EJoinFilteredBSideColumnOnly) { + // Only b-side columns requested -> single hash pass. + // a = [10, 20, 30, 40], b = [30, 10], d = [300, 100]. + // Filtered output (b-side): [100, 300] (order follows a's hit sequence). + std::vector a = {10, 20, 30, 40}; + std::vector b = {30, 10}; + std::vector d = {300, 100}; + + auto raw = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto bidx = MakeCompactIndex(std::move(raw)); + auto gather = MakeGather(std::make_unique(d), std::move(bidx), + std::make_unique(static_cast(0))); + auto r = RunExpr(std::move(gather)); + std::vector expect = {100, 300}; + EXPECT_EQ(std::get>(r), expect); +} + +TEST(ListIndexingTest, E2EJoinFilteredBothSides) { + // Full inner-join shape: keep both a-side (a, c) and b-side (d) columns for + // rows where a[i] matches something in b. + // a = [10, 20, 30, 40], c = [11, 22, 33, 44] (a-side) + // b = [30, 10], d = [300, 100] (b-side) + // Hits (in a-order): i=0 (a=10 -> b[1]), i=2 (a=30 -> b[0]). + // Expected: + // a_out = [10, 30] + // c_out = [11, 33] + // d_out = [100, 300] + std::vector a = {10, 20, 30, 40}; + std::vector c = {11, 22, 33, 44}; + std::vector b = {30, 10}; + std::vector d = {300, 100}; + + // a-side: ListGather(a, ListCompactPositions(ListLookupIndex(a, b)), 0) + { + auto raw = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto aidx = MakeCompactPositions(std::move(raw)); + auto gather = MakeGather(std::make_unique(a), std::move(aidx), + std::make_unique(static_cast(0))); + auto r = RunExpr(std::move(gather)); + std::vector expect = {10, 30}; + EXPECT_EQ(std::get>(r), expect); + } + // c-side: same aidx pattern, different values list. + { + auto raw = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto aidx = MakeCompactPositions(std::move(raw)); + auto gather = MakeGather(std::make_unique(c), std::move(aidx), + std::make_unique(static_cast(0))); + auto r = RunExpr(std::move(gather)); + std::vector expect = {11, 33}; + EXPECT_EQ(std::get>(r), expect); + } + // d-side: ListGather(d, ListCompactIndex(ListLookupIndex(a, b)), 0) + { + auto raw = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto bidx = MakeCompactIndex(std::move(raw)); + auto gather = MakeGather(std::make_unique(d), std::move(bidx), + std::make_unique(static_cast(0))); + auto r = RunExpr(std::move(gather)); + std::vector expect = {100, 300}; + EXPECT_EQ(std::get>(r), expect); + } +} + +TEST(ListIndexingTest, E2EJoinFilteredStringKeys) { + // Keys are strings; values can be any type. + std::vector a = {"alice", "bob", "carol", "dave"}; + std::vector b = {"carol", "alice"}; + std::vector d = {333, 111}; + + auto raw = MakeLookup(std::make_unique(a), std::make_unique(b)); + auto bidx = MakeCompactIndex(std::move(raw)); + auto gather = MakeGather(std::make_unique(d), std::move(bidx), + std::make_unique(static_cast(0))); + auto r = RunExpr(std::move(gather)); + std::vector expect = {111, 333}; // alice -> 111, carol -> 333 + EXPECT_EQ(std::get>(r), expect); +} From b24ed2e17c5fbca513c238b26d9e185edddb3ea9 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 12:49:36 +0800 Subject: [PATCH 08/41] revert build --- BUILD | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/BUILD b/BUILD index 003dcb2..e38bdb3 100644 --- a/BUILD +++ b/BUILD @@ -18,7 +18,7 @@ cc_library( "-DNDEBUG", "-ftree-vectorize", #"-g", - "-Rpass=loop-vectorize", + #"-Rpass=loop-vectorize", "-DHAS_XSIMD", ], ) From ef4fc222d7b9c22d2ea1bd28e48fb5ac4f704855 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 14:49:50 +0800 Subject: [PATCH 09/41] add Find function --- benchmark/bench_list_indexing.cc | 114 ++++++++++++++ doc/function.md | 38 +++++ src/function/list_indexing.cc | 134 +++++++++++++++++ test/list_indexing_test.cc | 250 +++++++++++++++++++++++++++++++ 4 files changed, 536 insertions(+) diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc index 3f1fe4e..bbbbb42 100644 --- a/benchmark/bench_list_indexing.cc +++ b/benchmark/bench_list_indexing.cc @@ -161,4 +161,118 @@ void BM_Execute_ListGather(benchmark::State& state) { } BENCHMARK(BM_Execute_ListGather)->Arg(256)->Arg(4096); +// Find(a, value). Two patterns: +// * Middle-hit: value lives in the middle of the list (avg-case ~len/2 scan). +// * All-miss : value is absent (worst-case full scan, len comparisons). +void BM_Execute_Find_MidHit(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + a.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back(i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantValueNode(static_cast(len / 2))); + std::unique_ptr node(new FunctionNode("Find", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_Find_MidHit)->Arg(256)->Arg(4096); + +void BM_Execute_Find_AllMiss(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + a.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back(i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantValueNode(static_cast(-1))); // not present + std::unique_ptr node(new FunctionNode("Find", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_Find_AllMiss)->Arg(256)->Arg(4096); + +// FindSorted: O(log n) binary-search counterpart of Find. Expected to scale far +// better than Find on large sorted lists; paired with the Find benchmarks so +// the gap is easy to read off. +void BM_Execute_FindSorted_MidHit(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + a.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back(i); // already sorted ascending + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantValueNode(static_cast(len / 2))); + std::unique_ptr node(new FunctionNode("FindSorted", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_FindSorted_MidHit)->Arg(256)->Arg(4096); + +void BM_Execute_FindSorted_AllMiss(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + a.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back(i); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantValueNode(static_cast(-1))); // below min + std::unique_ptr node(new FunctionNode("FindSorted", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_FindSorted_AllMiss)->Arg(256)->Arg(4096); + } // namespace diff --git a/doc/function.md b/doc/function.md index f9a8a08..0879b09 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1371,6 +1371,44 @@ The output length always equals `a.len`. u32list ListLookupIndex(f64list a, f64list b, ptr exec_ctx) u32list ListLookupIndex(stringlist a, stringlist b, ptr exec_ctx) +## Find +Return the index of the first occurrence of `value` in the list. Returns `u32max` (`std::numeric_limits::max()`) when the value is not found. This is the scalar counterpart of `ListLookupIndex` and composes naturally with `GetAt`: `GetAt(values, Find(keys, k))` performs a scalar join (miss falls through to `GetAt`'s out-of-bounds default of zero/empty). + + u32 Find(u8list a, u8 value) + u32 Find(i8list a, i8 value) + u32 Find(u16list a, u16 value) + u32 Find(i16list a, i16 value) + u32 Find(u32list a, u32 value) + u32 Find(i32list a, i32 value) + u32 Find(u64list a, u64 value) + u32 Find(i64list a, i64 value) + u32 Find(f32list a, f32 value) + u32 Find(f64list a, f64 value) + u32 Find(stringlist a, string value) + +## FindSorted +Binary-search version of `Find`: O(log n) instead of O(n). The caller **must** guarantee `a` is sorted in ascending order (lexicographic order for `stringlist`); otherwise the result is unspecified. Returns `u32max` (same miss sentinel as `Find`) when `value` is absent, and the index of the first equal element when duplicates exist (same as `std::lower_bound`). + +Use this over `Find` when the key list is large and known to be sorted (e.g. a pre-sorted dimension table). + + u32 FindSorted(u8list a, u8 value) + u32 FindSorted(i8list a, i8 value) + u32 FindSorted(u16list a, u16 value) + u32 FindSorted(i16list a, i16 value) + u32 FindSorted(u32list a, u32 value) + u32 FindSorted(i32list a, i32 value) + u32 FindSorted(u64list a, u64 value) + u32 FindSorted(i64list a, i64 value) + u32 FindSorted(f32list a, f32 value) + u32 FindSorted(f64list a, f64 value) + u32 FindSorted(stringlist a, string value) + +## FindMiss +Zero-arg function that returns the lookup-miss sentinel (`u32max`, i.e. `std::numeric_limits::max()`). Use this instead of spelling out `4294967295u32` when you need to compare against the miss value, e.g. `Find(keys, k) != FindMiss()`. Being a read-only pure function with no inputs, it is constant-folded at JIT time and has zero runtime cost. + + u32 FindMiss() + + ## ListCompactPositions Takes a `u32list` produced by `ListLookupIndex` and returns the positions in `a` that hit (i.e. the indices in the raw list whose value is **not** the miss sentinel `u32max`). Useful for building the filtered a-side of a join. diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index 9f49053..cc3c80e 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -4,11 +4,13 @@ * @Last Modified by: victorika * @Last Modified time: 2026-05-06 11:15:00 */ +#include #include #include #include #include +#include "codegen/codegen.h" #include "exec_engine.h" #include "function_init.h" #include "function_registry.h" @@ -41,6 +43,56 @@ U32ListStruct ListLookupIndex(KList a, KList b, void *exec_context) { return result; } +template +uint32_t Find(KList a, typename KList::CElementType value) { + for (uint32_t i = 0; i < a.len; ++i) { + if (a.data[i] == value) { + return i; + } + } + return kLookupMiss; +} + +uint32_t FindString(StringListStruct a, StringStruct value) { + std::string_view needle(value.data, value.len); + for (uint32_t i = 0; i < a.len; ++i) { + std::string_view sv(a.data[i].data, a.data[i].len); + if (sv == needle) { + return i; + } + } + return kLookupMiss; +} + +template +uint32_t FindSorted(KList a, typename KList::CElementType value) { + const auto *begin = a.data; + const auto *end = a.data + a.len; + const auto *it = std::lower_bound(begin, end, value); + if (it == end || *it != value) { + return kLookupMiss; + } + return static_cast(it - begin); +} + +uint32_t FindSortedString(StringListStruct a, StringStruct value) { + std::string_view needle(value.data, value.len); + const auto *begin = a.data; + const auto *end = a.data + a.len; + const auto *it = std::lower_bound(begin, end, needle, [](const StringStruct &lhs, std::string_view rhs) { + return std::string_view(lhs.data, lhs.len) < rhs; + }); + if (it == end || std::string_view(it->data, it->len) != needle) { + return kLookupMiss; + } + return static_cast(it - begin); +} + +llvm::Value *CodegenFindMiss(const FunctionSignature & /*sign*/, const std::vector & /*arg_types*/, + const std::vector & /*args*/, IRCodeGenContext &ctx) { + return ctx.builder.getInt32(kLookupMiss); +} + U32ListStruct ListLookupIndexString(StringListStruct a, StringListStruct b, void *exec_context) { auto *exec_ctx = reinterpret_cast(exec_context); U32ListStruct result; @@ -166,6 +218,85 @@ Status InitListLookupIndexFunc(FunctionRegistry *reg) { return Status::OK(); } +Status InitFindFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kU8List, ValueType::kU8}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kI8List, ValueType::kI8}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kU16List, ValueType::kU16}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kI16List, ValueType::kI16}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kI32List, ValueType::kI32}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kU64List, ValueType::kU64}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kI64List, ValueType::kI64}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kF32List, ValueType::kF32}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("Find", {ValueType::kF64List, ValueType::kF64}, ValueType::kU32), + reinterpret_cast(Find))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Find", {ValueType::kStringList, ValueType::kString}, ValueType::kU32), + reinterpret_cast(FindString))); + return Status::OK(); +} + +Status InitFindSortedFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("FindSorted", {ValueType::kU8List, ValueType::kU8}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFunc(FunctionSignature("FindSorted", {ValueType::kI8List, ValueType::kI8}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kU16List, ValueType::kU16}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kI16List, ValueType::kI16}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kI32List, ValueType::kI32}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kU64List, ValueType::kU64}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kI64List, ValueType::kI64}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kF32List, ValueType::kF32}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kF64List, ValueType::kF64}, ValueType::kU32), + reinterpret_cast(FindSorted))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("FindSorted", {ValueType::kStringList, ValueType::kString}, ValueType::kU32), + reinterpret_cast(FindSortedString))); + return Status::OK(); +} + +Status InitFindMissFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc(FunctionSignature("FindMiss", {}, ValueType::kU32), CodegenFindMiss)); + return Status::OK(); +} + Status InitListCompactFuncs(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( FunctionSignature("ListCompactPositions", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), @@ -230,6 +361,9 @@ Status InitListGatherFunc(FunctionRegistry *reg) { Status InitListIndexingFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitListLookupIndexFunc(reg)); + JF_RETURN_NOT_OK(InitFindFunc(reg)); + JF_RETURN_NOT_OK(InitFindSortedFunc(reg)); + JF_RETURN_NOT_OK(InitFindMissFunc(reg)); JF_RETURN_NOT_OK(InitListCompactFuncs(reg)); JF_RETURN_NOT_OK(InitListGatherFunc(reg)); return Status::OK(); diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc index bea2341..96aca93 100644 --- a/test/list_indexing_test.cc +++ b/test/list_indexing_test.cc @@ -56,6 +56,31 @@ std::unique_ptr MakeGather(std::unique_ptr values, std::uniq return std::make_unique("ListGather", std::move(args)); } +std::unique_ptr MakeFind(std::unique_ptr a, std::unique_ptr value) { + std::vector> args; + args.emplace_back(std::move(a)); + args.emplace_back(std::move(value)); + return std::make_unique("Find", std::move(args)); +} + +std::unique_ptr MakeFindSorted(std::unique_ptr a, std::unique_ptr value) { + std::vector> args; + args.emplace_back(std::move(a)); + args.emplace_back(std::move(value)); + return std::make_unique("FindSorted", std::move(args)); +} + +std::unique_ptr MakeFindMiss() { + return std::make_unique("FindMiss", std::vector>{}); +} + +std::unique_ptr MakeGetAt(std::unique_ptr values, std::unique_ptr index) { + std::vector> args; + args.emplace_back(std::move(values)); + args.emplace_back(std::move(index)); + return std::make_unique("GetAt", std::move(args)); +} + RetType RunExpr(std::unique_ptr root, Status *status_out = nullptr) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); @@ -360,3 +385,228 @@ TEST(ListIndexingTest, E2EJoinFilteredStringKeys) { std::vector expect = {111, 333}; // alice -> 111, carol -> 333 EXPECT_EQ(std::get>(r), expect); } + +// ----------------------------------------------------------------------------- +// Find: return the index of the first occurrence of `value` in the list. +// Miss -> std::numeric_limits::max() (kMiss), which naturally +// composes with GetAt (out-of-bounds -> zero-valued default). +// ----------------------------------------------------------------------------- + +TEST(ListIndexingTest, FindI32Basic) { + std::vector a = {10, 20, 30, 40}; + auto node = MakeFind(std::make_unique(a), + std::make_unique(static_cast(30))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindI32Miss) { + std::vector a = {10, 20, 30}; + auto node = MakeFind(std::make_unique(a), + std::make_unique(static_cast(99))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindI32DuplicateReturnsFirst) { + std::vector a = {7, 8, 7, 7}; + auto node = MakeFind(std::make_unique(a), + std::make_unique(static_cast(7))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 0U); +} + +TEST(ListIndexingTest, FindEmptyList) { + std::vector a = {}; + auto node = MakeFind(std::make_unique(a), + std::make_unique(static_cast(1))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindU64) { + std::vector a = {100, 200, 300}; + auto node = MakeFind(std::make_unique(a), + std::make_unique(static_cast(300))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindF64) { + std::vector a = {1.5, 2.5, 3.5}; + auto node = MakeFind(std::make_unique(a), std::make_unique(2.5)); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 1U); +} + +TEST(ListIndexingTest, FindString) { + std::vector a = {"alice", "bob", "carol"}; + auto node = + MakeFind(std::make_unique(a), std::make_unique(std::string("carol"))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindStringMiss) { + std::vector a = {"alice", "bob"}; + auto node = + MakeFind(std::make_unique(a), std::make_unique(std::string("zoe"))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +// E2E: scalar join == GetAt(values, Find(keys, k)) +// Hit: returns the matched value; Miss: Find -> kMiss, GetAt -> zero-valued +// default (0 for ints). This demonstrates the intended composition. +TEST(ListIndexingTest, E2EScalarJoinHit) { + std::vector keys = {10, 20, 30}; + std::vector values = {100, 200, 300}; + auto find = MakeFind(std::make_unique(keys), + std::make_unique(static_cast(20))); + auto getat = MakeGetAt(std::make_unique(values), std::move(find)); + auto result = RunExpr(std::move(getat)); + EXPECT_EQ(std::get(result), 200); +} + +TEST(ListIndexingTest, E2EScalarJoinMiss) { + std::vector keys = {10, 20, 30}; + std::vector values = {100, 200, 300}; + auto find = MakeFind(std::make_unique(keys), + std::make_unique(static_cast(99))); + auto getat = MakeGetAt(std::make_unique(values), std::move(find)); + auto result = RunExpr(std::move(getat)); + // Find returns kMiss -> GetAt goes out-of-bounds -> returns 0 for int32. + EXPECT_EQ(std::get(result), 0); +} + +// ----------------------------------------------------------------------------- +// FindSorted: O(log n) binary search variant of Find. The caller MUST guarantee +// the list is sorted in ascending order; otherwise the result is unspecified +// (same contract as std::lower_bound). On miss returns kMiss. +// ----------------------------------------------------------------------------- + +TEST(ListIndexingTest, FindSortedI32MidHit) { + std::vector a = {10, 20, 30, 40, 50}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(30))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindSortedI32LeftBoundary) { + std::vector a = {10, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(10))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 0U); +} + +TEST(ListIndexingTest, FindSortedI32RightBoundary) { + std::vector a = {10, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(30))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindSortedI32MissBelow) { + std::vector a = {10, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(5))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindSortedI32MissAbove) { + std::vector a = {10, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(99))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindSortedI32MissInGap) { + std::vector a = {10, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(15))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindSortedEmptyList) { + std::vector a = {}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(1))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindSortedI32DuplicatesReturnsFirst) { + // std::lower_bound naturally returns the first equal element. + std::vector a = {10, 20, 20, 20, 30}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(20))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 1U); +} + +TEST(ListIndexingTest, FindSortedU64) { + std::vector a = {100, 200, 300, 400}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(300))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindSortedF64) { + std::vector a = {1.5, 2.5, 3.5}; + auto node = MakeFindSorted(std::make_unique(a), std::make_unique(2.5)); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 1U); +} + +TEST(ListIndexingTest, FindSortedStringHit) { + // Strings must be in lexicographic ascending order. + std::vector a = {"alice", "bob", "carol", "dave"}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(std::string("carol"))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), 2U); +} + +TEST(ListIndexingTest, FindSortedStringMiss) { + std::vector a = {"alice", "bob", "carol"}; + auto node = MakeFindSorted(std::make_unique(a), + std::make_unique(std::string("zoe"))); + auto result = RunExpr(std::move(node)); + EXPECT_EQ(std::get(result), kMiss); +} + +// ----------------------------------------------------------------------------- +// FindMiss: zero-arg constant that equals the lookup-miss sentinel. Intended +// for DSL-side use so users can write `Find(keys, k) != FindMiss()`. +// ----------------------------------------------------------------------------- + +TEST(ListIndexingTest, FindMissEqualsKMiss) { + auto result = RunExpr(MakeFindMiss()); + EXPECT_EQ(std::get(result), kMiss); +} + +TEST(ListIndexingTest, FindMissMatchesFindMiss) { + // Find miss path must return the same sentinel as FindMiss(). + std::vector a = {10, 20, 30}; + auto find = MakeFind(std::make_unique(a), + std::make_unique(static_cast(99))); + auto find_result = RunExpr(std::move(find)); + auto miss_result = RunExpr(MakeFindMiss()); + EXPECT_EQ(std::get(find_result), std::get(miss_result)); +} + +TEST(ListIndexingTest, FindMissMatchesFindSortedMiss) { + std::vector a = {10, 20, 30}; + auto find = MakeFindSorted(std::make_unique(a), + std::make_unique(static_cast(99))); + auto find_result = RunExpr(std::move(find)); + auto miss_result = RunExpr(MakeFindMiss()); + EXPECT_EQ(std::get(find_result), std::get(miss_result)); +} From bdd8986b71216bed1e4e88aefcdbec7f7b60ae5d Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 16:02:14 +0800 Subject: [PATCH 10/41] add CrossJoin function --- benchmark/bench_list_basic.cc | 37 ++++++++++++++++++++ doc/function.md | 14 ++++++++ src/function/list_basic.cc | 63 +++++++++++++++++++++++++++++++++++ test/list_basic_test.cc | 63 +++++++++++++++++++++++++++++++++++ 4 files changed, 177 insertions(+) diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc index 6585ec6..ab3ee9c 100644 --- a/benchmark/bench_list_basic.cc +++ b/benchmark/bench_list_basic.cc @@ -175,6 +175,43 @@ void BM_Execute_ListConcat(benchmark::State& state) { } BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096); +// CrossJoin(stringlist a, stringlist b, string sep, ctx) — produces a +// length-(|a| * |b|) stringlist of "a[i] + sep + b[j]". Output size is +// quadratic in the input length, so we sweep the per-side length from 16..256 +// (yielding 256..65536 output elements) instead of the usual 256/4096 sweep +// used for linear-cost kernels. +void BM_Execute_CrossJoin(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + std::vector b; + a.reserve(len); + b.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back("a" + std::to_string(i)); + b.push_back("b" + std::to_string(i)); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantListValueNode(std::move(b))); + args.emplace_back(new ConstantValueNode(std::string("_"))); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("CrossJoin", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_CrossJoin)->Arg(16)->Arg(64)->Arg(256); + // `in(needle, haystack_list)` — scalar-in-list membership test (not list-out). void BM_Execute_ListIn(benchmark::State& state) { const int len = static_cast(state.range(0)); diff --git a/doc/function.md b/doc/function.md index 0879b09..0fa4638 100644 --- a/doc/function.md +++ b/doc/function.md @@ -318,6 +318,20 @@ Concatenating two lists returns a new list. f64list ListConcat(f64list lhs, f64list rhs, ptr exec_ctx) stringlist ListConcat(stringlist lhs, stringlist rhs, ptr exec_ctx) +## CrossJoin +Cartesian-product string concatenation. Given an outer list `a`, an inner list `b` +and a separator `sep`, produces a string list of length `len(a) * len(b)` where +`result[i * len(b) + j] == a[i] + sep + b[j]`. The outer list iterates slower, +the inner list iterates faster (row-major order). + +Example: `CrossJoin(["1","2","3"], ["a","b","c"], "_") == +["1_a","1_b","1_c","2_a","2_b","2_c","3_a","3_b","3_c"]`. + +If either input list is empty, the result is empty. Numeric lists are not +accepted directly — convert them to `stringlist` first via `CastStringList`. + + stringlist CrossJoin(stringlist a, stringlist b, string sep, ptr exec_ctx) + ## in Check if it is in the list. diff --git a/src/function/list_basic.cc b/src/function/list_basic.cc index 1771bf0..0caff47 100644 --- a/src/function/list_basic.cc +++ b/src/function/list_basic.cc @@ -196,6 +196,59 @@ ListType Unique(ListType a, void *exec_context) { return result; } +inline StringListStruct CrossJoinString(StringListStruct a, StringListStruct b, StringStruct sep, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + StringListStruct result; + uint64_t total_elems = static_cast(a.len) * static_cast(b.len); + result.len = static_cast(total_elems); + if (total_elems == 0) { + result.data = nullptr; + return result; + } + + uint64_t a_bytes = 0; + for (uint32_t i = 0; i < a.len; ++i) { + a_bytes += a.data[i].len; + } + uint64_t b_bytes = 0; + for (uint32_t j = 0; j < b.len; ++j) { + b_bytes += b.data[j].len; + } + // Each output element contributes (|a[i]| + |sep| + |b[j]|) bytes; summed: + // sum_i sum_j (|a[i]| + |sep| + |b[j]|) + // = b.len * sum_i |a[i]| + a.len * sum_j |b[j]| + a.len * b.len * |sep| + uint64_t total_bytes = (a_bytes * b.len) + (b_bytes * a.len) + (total_elems * sep.len); + + result.data = reinterpret_cast(exec_ctx->arena.Allocate(total_elems * sizeof(StringStruct))); + char *buf = total_bytes == 0 ? nullptr : reinterpret_cast(exec_ctx->arena.Allocate(total_bytes)); + + char *cursor = buf; + uint32_t out_idx = 0; + for (uint32_t i = 0; i < a.len; ++i) { + const StringStruct &av = a.data[i]; + for (uint32_t j = 0; j < b.len; ++j) { + const StringStruct &bv = b.data[j]; + char *start = cursor; + if (av.len > 0) { + memcpy(cursor, av.data, av.len); + cursor += av.len; + } + if (sep.len > 0) { + memcpy(cursor, sep.data, sep.len); + cursor += sep.len; + } + if (bv.len > 0) { + memcpy(cursor, bv.data, bv.len); + cursor += bv.len; + } + result.data[out_idx].data = start; + result.data[out_idx].len = static_cast(cursor - start); + ++out_idx; + } + } + return result; +} + inline StringListStruct UniqueString(StringListStruct a, void *exec_context) { auto *exec_ctx = reinterpret_cast(exec_context); StringListStruct result; @@ -213,6 +266,15 @@ inline StringListStruct UniqueString(StringListStruct a, void *exec_context) { return result; } +Status InitCrossJoinFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("CrossJoin", + {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + ValueType::kStringList), + reinterpret_cast(CrossJoinString))); + return Status::OK(); +} + Status InitUniqueFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK( reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), @@ -585,6 +647,7 @@ Status InitListBasicFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitHashFunc(reg)); JF_RETURN_NOT_OK(InitListCastFunc(reg)); JF_RETURN_NOT_OK(InitUniqueFunc(reg)); + JF_RETURN_NOT_OK(InitCrossJoinFunc(reg)); return Status::OK(); } diff --git a/test/list_basic_test.cc b/test/list_basic_test.cc index d48c33f..cf6bc03 100644 --- a/test/list_basic_test.cc +++ b/test/list_basic_test.cc @@ -208,3 +208,66 @@ TEST(FunctionTest, TruncateTest4) { std::vector expect(data.begin(), data.end()); EXPECT_EQ(std::get>(result), expect); } + +namespace { +std::vector RunCrossJoin(const std::vector& a, const std::vector& b, + const std::string& sep) { + std::unique_ptr func_registry; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + auto a_node = std::unique_ptr(new ConstantListValueNode(a)); + auto b_node = std::unique_ptr(new ConstantListValueNode(b)); + auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); + auto exec_node = std::unique_ptr(new ExecContextNode); + std::vector> args_list; + args_list.emplace_back(std::move(a_node)); + args_list.emplace_back(std::move(b_node)); + args_list.emplace_back(std::move(sep_node)); + args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CrossJoin", std::move(args_list))); + ExecEngine exec_engine; + auto st = exec_engine.Compile(op_node, func_registry); + EXPECT_TRUE(st.ok()) << st.ToString(); + RetType result; + EXPECT_TRUE(exec_engine.Execute(nullptr, &result).ok()); + return std::get>(result); +} +} // namespace + +TEST(FunctionTest, CrossJoinBasicTest) { + // Mirrors the spec example: outer-major (a is outer, b is inner). + auto got = RunCrossJoin({"1", "2", "3"}, {"a", "b", "c"}, "_"); + std::vector expect = {"1_a", "1_b", "1_c", "2_a", "2_b", "2_c", "3_a", "3_b", "3_c"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, CrossJoinEmptySepTest) { + auto got = RunCrossJoin({"x", "y"}, {"1", "2"}, ""); + std::vector expect = {"x1", "x2", "y1", "y2"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, CrossJoinMultiCharSepTest) { + auto got = RunCrossJoin({"foo", "bar"}, {"baz"}, "::"); + std::vector expect = {"foo::baz", "bar::baz"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, CrossJoinSingletonTest) { + // 1xN and Nx1 shapes. + EXPECT_EQ(RunCrossJoin({"a"}, {"x", "y", "z"}, "-"), (std::vector{"a-x", "a-y", "a-z"})); + EXPECT_EQ(RunCrossJoin({"x", "y", "z"}, {"a"}, "-"), (std::vector{"x-a", "y-a", "z-a"})); +} + +TEST(FunctionTest, CrossJoinEmptyInputTest) { + // Either side empty -> empty result. + EXPECT_TRUE(RunCrossJoin({}, {"a", "b"}, "_").empty()); + EXPECT_TRUE(RunCrossJoin({"a", "b"}, {}, "_").empty()); + EXPECT_TRUE(RunCrossJoin({}, {}, "_").empty()); +} + +TEST(FunctionTest, CrossJoinEmptyElementTest) { + // Empty strings in inputs are valid and should produce sep-only joins. + auto got = RunCrossJoin({"", "a"}, {"", "b"}, "_"); + std::vector expect = {"_", "_b", "a_", "a_b"}; + EXPECT_EQ(got, expect); +} From f8f3618ebcacb43cbe18d96df148ba8d999f13ef Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 16:41:11 +0800 Subject: [PATCH 11/41] add ZipConcat --- benchmark/bench_list_basic.cc | 36 ++++++++++++++++ doc/function.md | 14 +++++++ src/function/list_basic.cc | 64 +++++++++++++++++++++++++++- test/list_basic_test.cc | 78 +++++++++++++++++++++++++++++++++++ 4 files changed, 190 insertions(+), 2 deletions(-) diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc index ab3ee9c..c9d95f7 100644 --- a/benchmark/bench_list_basic.cc +++ b/benchmark/bench_list_basic.cc @@ -212,6 +212,42 @@ void BM_Execute_CrossJoin(benchmark::State& state) { } BENCHMARK(BM_Execute_CrossJoin)->Arg(16)->Arg(64)->Arg(256); +// ZipConcat(stringlist a, stringlist b, string sep, ctx) — per-position +// concatenation, output length equals |a| (== |b|). Linear cost in input +// length, so it shares the standard 256/4096 sweep with the other linear +// list kernels. +void BM_Execute_ZipConcat(benchmark::State& state) { + const int len = static_cast(state.range(0)); + auto reg = MakeRegistry(); + std::vector a; + std::vector b; + a.reserve(len); + b.reserve(len); + for (int i = 0; i < len; ++i) { + a.push_back("a" + std::to_string(i)); + b.push_back("b" + std::to_string(i)); + } + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(a))); + args.emplace_back(new ConstantListValueNode(std::move(b))); + args.emplace_back(new ConstantValueNode(std::string(":"))); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ZipConcat", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_ZipConcat)->Arg(256)->Arg(4096); + // `in(needle, haystack_list)` — scalar-in-list membership test (not list-out). void BM_Execute_ListIn(benchmark::State& state) { const int len = static_cast(state.range(0)); diff --git a/doc/function.md b/doc/function.md index 0fa4638..7e47ece 100644 --- a/doc/function.md +++ b/doc/function.md @@ -332,6 +332,20 @@ accepted directly — convert them to `stringlist` first via `CastStringList`. stringlist CrossJoin(stringlist a, stringlist b, string sep, ptr exec_ctx) +## ZipConcat +Per-position string concatenation. Pairs up `a[i]` with `b[i]` and produces a +string list of the same length where `result[i] == a[i] + sep + b[i]`. This is +the "zip" pattern from Python / Rust / Haskell. + +Example: `ZipConcat(["a","b","c"], ["6","7","8"], ":") == ["a:6","b:7","c:8"]`. + +The two input lists must have equal length; a length mismatch is reported via +`ExecContext::AddError` and surfaces as a non-OK Status from `Execute`. +Numeric lists are not accepted directly — convert them to `stringlist` first +via `CastStringList`. + + stringlist ZipConcat(stringlist a, stringlist b, string sep, ptr exec_ctx) + ## in Check if it is in the list. diff --git a/src/function/list_basic.cc b/src/function/list_basic.cc index 0caff47..427d036 100644 --- a/src/function/list_basic.cc +++ b/src/function/list_basic.cc @@ -225,9 +225,9 @@ inline StringListStruct CrossJoinString(StringListStruct a, StringListStruct b, char *cursor = buf; uint32_t out_idx = 0; for (uint32_t i = 0; i < a.len; ++i) { - const StringStruct &av = a.data[i]; + const StringStruct av = a.data[i]; for (uint32_t j = 0; j < b.len; ++j) { - const StringStruct &bv = b.data[j]; + const StringStruct bv = b.data[j]; char *start = cursor; if (av.len > 0) { memcpy(cursor, av.data, av.len); @@ -275,6 +275,65 @@ Status InitCrossJoinFunc(FunctionRegistry *reg) { return Status::OK(); } +inline StringListStruct ZipConcatString(StringListStruct a, StringListStruct b, StringStruct sep, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + if (a.len != b.len) { + exec_ctx->AddError("ZipConcat: lhs and rhs len mismatch, lhs len: " + std::to_string(a.len) + + ", rhs len: " + std::to_string(b.len)); + return {nullptr, 0}; + } + + StringListStruct result; + result.len = a.len; + if (a.len == 0) { + result.data = nullptr; + return result; + } + + // First pass: total bytes for the output buffer. + // sum_i (|a[i]| + |sep| + |b[i]|) = (sum |a|) + (sum |b|) + n * |sep| + uint64_t total_bytes = 0; + for (uint32_t i = 0; i < a.len; ++i) { + total_bytes += a.data[i].len; + total_bytes += b.data[i].len; + } + total_bytes += static_cast(a.len) * sep.len; + + result.data = reinterpret_cast(exec_ctx->arena.Allocate(a.len * sizeof(StringStruct))); + char *buf = total_bytes == 0 ? nullptr : reinterpret_cast(exec_ctx->arena.Allocate(total_bytes)); + + char *cursor = buf; + for (uint32_t i = 0; i < a.len; ++i) { + const StringStruct av = a.data[i]; + const StringStruct bv = b.data[i]; + char *start = cursor; + if (av.len > 0) { + memcpy(cursor, av.data, av.len); + cursor += av.len; + } + if (sep.len > 0) { + memcpy(cursor, sep.data, sep.len); + cursor += sep.len; + } + if (bv.len > 0) { + memcpy(cursor, bv.data, bv.len); + cursor += bv.len; + } + result.data[i].data = start; + result.data[i].len = static_cast(cursor - start); + } + return result; +} + +Status InitZipConcatFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("ZipConcat", + {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + ValueType::kStringList), + reinterpret_cast(ZipConcatString))); + return Status::OK(); +} + Status InitUniqueFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK( reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), @@ -648,6 +707,7 @@ Status InitListBasicFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitListCastFunc(reg)); JF_RETURN_NOT_OK(InitUniqueFunc(reg)); JF_RETURN_NOT_OK(InitCrossJoinFunc(reg)); + JF_RETURN_NOT_OK(InitZipConcatFunc(reg)); return Status::OK(); } diff --git a/test/list_basic_test.cc b/test/list_basic_test.cc index cf6bc03..a63470b 100644 --- a/test/list_basic_test.cc +++ b/test/list_basic_test.cc @@ -271,3 +271,81 @@ TEST(FunctionTest, CrossJoinEmptyElementTest) { std::vector expect = {"_", "_b", "a_", "a_b"}; EXPECT_EQ(got, expect); } + +namespace { +// Build the ZipConcat expression node — separated from execution so that +// error-path tests can inspect Status without going through a helper that +// asserts ok(). +std::unique_ptr MakeZipConcatExpr(const std::vector& a, const std::vector& b, + const std::string& sep) { + auto a_node = std::unique_ptr(new ConstantListValueNode(a)); + auto b_node = std::unique_ptr(new ConstantListValueNode(b)); + auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); + auto exec_node = std::unique_ptr(new ExecContextNode); + std::vector> args_list; + args_list.emplace_back(std::move(a_node)); + args_list.emplace_back(std::move(b_node)); + args_list.emplace_back(std::move(sep_node)); + args_list.emplace_back(std::move(exec_node)); + return std::unique_ptr(new FunctionNode("ZipConcat", std::move(args_list))); +} + +std::vector RunZipConcat(const std::vector& a, const std::vector& b, + const std::string& sep) { + std::unique_ptr func_registry; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + auto op_node = MakeZipConcatExpr(a, b, sep); + ExecEngine exec_engine; + auto st = exec_engine.Compile(op_node, func_registry); + EXPECT_TRUE(st.ok()) << st.ToString(); + RetType result; + EXPECT_TRUE(exec_engine.Execute(nullptr, &result).ok()); + return std::get>(result); +} +} // namespace + +TEST(FunctionTest, ZipConcatBasicTest) { + // Pair-wise concatenation: a[i] + sep + b[i]. + auto got = RunZipConcat({"a", "b", "c"}, {"6", "7", "8"}, ":"); + std::vector expect = {"a:6", "b:7", "c:8"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, ZipConcatEmptySepTest) { + auto got = RunZipConcat({"x", "y", "z"}, {"1", "2", "3"}, ""); + std::vector expect = {"x1", "y2", "z3"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, ZipConcatMultiCharSepTest) { + auto got = RunZipConcat({"foo", "bar"}, {"baz", "qux"}, "::"); + std::vector expect = {"foo::baz", "bar::qux"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, ZipConcatEmptyInputTest) { + // Both empty -> empty result, no error. + EXPECT_TRUE(RunZipConcat({}, {}, "_").empty()); +} + +TEST(FunctionTest, ZipConcatEmptyElementTest) { + // Empty strings on either side are valid; only sep remains in output. + auto got = RunZipConcat({"", "a", ""}, {"x", "", ""}, "_"); + std::vector expect = {"_x", "a_", "_"}; + EXPECT_EQ(got, expect); +} + +TEST(FunctionTest, ZipConcatLenMismatchReturnsError) { + // Length mismatch must surface as a runtime error via ExecContext::AddError, + // matching the convention used by ListAddList / GroupSum / etc. + std::unique_ptr func_registry; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + auto op_node = MakeZipConcatExpr({"a", "b", "c"}, {"1", "2"}, "_"); + ExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(op_node, func_registry).ok()); + RetType result; + Status st = exec_engine.Execute(nullptr, &result); + EXPECT_FALSE(st.ok()); + EXPECT_NE(st.ToString().find("ZipConcat"), std::string::npos); + EXPECT_NE(st.ToString().find("len mismatch"), std::string::npos); +} From 724277b28df28a2c1db8169421a128ae79d1c7e7 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 18:44:33 +0800 Subject: [PATCH 12/41] add Bucketize function --- benchmark/bench_list_indexing.cc | 44 ++++++++++ doc/function.md | 35 ++++++++ src/function/list_indexing.cc | 71 ++++++++++++++++ test/list_indexing_test.cc | 135 +++++++++++++++++++++++++++++++ 4 files changed, 285 insertions(+) diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc index bbbbb42..651129d 100644 --- a/benchmark/bench_list_indexing.cc +++ b/benchmark/bench_list_indexing.cc @@ -275,4 +275,48 @@ void BM_Execute_FindSorted_AllMiss(benchmark::State& state) { } BENCHMARK(BM_Execute_FindSorted_AllMiss)->Arg(256)->Arg(4096); +// Bucketize(values, boundaries, ctx). Per-element cost is +// O(log |boundaries|), so we sweep both axes: +// * values length: 256, 4096 (matches the rest of the file) +// * bucket count : 16, 256 (representative for feature-engineering use) +// Boundaries are evenly spaced and values are spread across the full range so +// the lower_bound walks both halves of the tree on average. +void BM_Execute_Bucketize(benchmark::State& state) { + const int len = static_cast(state.range(0)); + const int n_buckets = static_cast(state.range(1)); + auto reg = MakeRegistry(); + + std::vector values; + values.reserve(len); + for (int i = 0; i < len; ++i) { + // Spread values across [0, n_buckets * 100) so each bucket sees + // roughly equal traffic regardless of len. + values.push_back(static_cast((i * 1315423911LL) % (n_buckets * 100LL))); + } + std::vector boundaries; + boundaries.reserve(n_buckets); + for (int i = 1; i <= n_buckets; ++i) { + boundaries.push_back(static_cast(i * 100)); // 100, 200, ... + } + + std::vector> args; + args.emplace_back(new ConstantListValueNode(std::move(values))); + args.emplace_back(new ConstantListValueNode(std::move(boundaries))); + args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("Bucketize", std::move(args))); + + auto engine = CompileOrDie(std::move(node), reg); + ExecContext ctx(4096); + for (auto _ : state) { + ctx.Clear(); + RetType result; + auto st = engine->Execute(ctx, nullptr, &result); + benchmark::DoNotOptimize(result); + if (!st.ok()) { + state.SkipWithError("execute failed"); + } + } +} +BENCHMARK(BM_Execute_Bucketize)->Args({256, 16})->Args({256, 256})->Args({4096, 16})->Args({4096, 256}); + } // namespace diff --git a/doc/function.md b/doc/function.md index 7e47ece..e65094b 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1467,3 +1467,38 @@ The output length always equals `idx.len`. f32list ListGather(f32list values, u32list idx, f32 default_value, ptr exec_ctx) f64list ListGather(f64list values, u32list idx, f64 default_value, ptr exec_ctx) stringlist ListGather(stringlist values, u32list idx, string default_value, ptr exec_ctx) + +## Bucketize +Classify each element of `values` into a half-open bin defined by an +ascending `boundaries` list. Aligned with NumPy `digitize`, TensorFlow / +PyTorch `bucketize`, PostgreSQL `width_bucket(array)` and Apache Arrow's bin +kernel. + +For `boundaries = [b0, b1, ..., b_{n-1}]` the bin layout is + + bucket 0 : (-inf, b0) + bucket i (1..n-1) : [b_{i-1}, b_i) + bucket n : [b_{n-1}, +inf) + +i.e. left-closed / right-open. Result has the same length as `values`. + +* Out-of-range values land in bucket `0` or bucket `n` (no error). +* Empty `boundaries` collapses to a single `(-inf, +inf)` bucket — every + value returns `0`. +* For floating-point lists, `NaN` is mapped to the top bucket `n` + (matching NumPy / PyTorch). +* `boundaries` **must** be sorted ascending; like `FindSorted`, the result + is unspecified otherwise (no runtime check). + +Implementation is `std::lower_bound`, O(log n) per value. + + u32list Bucketize(u8list values, u8list boundaries, ptr exec_ctx) + u32list Bucketize(i8list values, i8list boundaries, ptr exec_ctx) + u32list Bucketize(u16list values, u16list boundaries, ptr exec_ctx) + u32list Bucketize(i16list values, i16list boundaries, ptr exec_ctx) + u32list Bucketize(u32list values, u32list boundaries, ptr exec_ctx) + u32list Bucketize(i32list values, i32list boundaries, ptr exec_ctx) + u32list Bucketize(u64list values, u64list boundaries, ptr exec_ctx) + u32list Bucketize(i64list values, i64list boundaries, ptr exec_ctx) + u32list Bucketize(f32list values, f32list boundaries, ptr exec_ctx) + u32list Bucketize(f64list values, f64list boundaries, ptr exec_ctx) diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index cc3c80e..1fb9e74 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -170,6 +170,42 @@ VList ListGather(VList values, U32ListStruct idx, typename VList::CElementType d return result; } +constexpr uint32_t kBucketizeLinearThreshold = 16; + +template +U32ListStruct Bucketize(ListType values, ListType boundaries, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + U32ListStruct result; + result.len = values.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * values.len)); + + const auto *bbegin = boundaries.data; + const uint32_t bn = boundaries.len; + + if (bn <= kBucketizeLinearThreshold) { + for (uint32_t i = 0; i < values.len; ++i) { + const auto v = values.data[i]; + uint32_t bucket = 0; + // `!(v < b)` is intentional, do NOT simplify to `v >= b` or `b <= v`: + // upper_bound uses the same `value < *it` predicate, so for NaN — where + // every comparison is false — both paths walk past the end and land in + // the top bucket. Switching to `>=` would map NaN to bucket 0 and break + // bit-for-bit parity with the binary-search path. + while (bucket < bn && !(v < bbegin[bucket])) { + ++bucket; + } + result.data[i] = bucket; + } + } else { + const auto *bend = bbegin + bn; + for (uint32_t i = 0; i < values.len; ++i) { + const auto *it = std::upper_bound(bbegin, bend, values.data[i]); + result.data[i] = static_cast(it - bbegin); + } + } + return result; +} + Status InitListLookupIndexFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( FunctionSignature("ListLookupIndex", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, @@ -357,6 +393,40 @@ Status InitListGatherFunc(FunctionRegistry *reg) { return Status::OK(); } +Status InitBucketizeFunc(FunctionRegistry *reg) { + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature("Bucketize", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(Bucketize))); + return Status::OK(); +} + } // namespace Status InitListIndexingFunc(FunctionRegistry *reg) { @@ -366,6 +436,7 @@ Status InitListIndexingFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(InitFindMissFunc(reg)); JF_RETURN_NOT_OK(InitListCompactFuncs(reg)); JF_RETURN_NOT_OK(InitListGatherFunc(reg)); + JF_RETURN_NOT_OK(InitBucketizeFunc(reg)); return Status::OK(); } diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc index 96aca93..4620f85 100644 --- a/test/list_indexing_test.cc +++ b/test/list_indexing_test.cc @@ -610,3 +610,138 @@ TEST(ListIndexingTest, FindMissMatchesFindSortedMiss) { auto miss_result = RunExpr(MakeFindMiss()); EXPECT_EQ(std::get(find_result), std::get(miss_result)); } + +// ---- Bucketize tests ------------------------------------------------------- + +namespace { + +// Build a Bucketize(values, boundaries, exec_ctx) FunctionNode. +template +std::unique_ptr MakeBucketize(const std::vector& values, const std::vector& boundaries) { + std::vector> args; + args.emplace_back(std::make_unique(values)); + args.emplace_back(std::make_unique(boundaries)); + args.emplace_back(std::make_unique()); + return std::make_unique("Bucketize", std::move(args)); +} + +template +std::vector RunBucketize(const std::vector& values, const std::vector& boundaries) { + auto result = RunExpr(MakeBucketize(values, boundaries)); + return std::get>(result); +} + +} // namespace + +TEST(ListIndexingTest, BucketizeBasicI32) { + // boundaries = [10, 20, 30] -> 4 buckets: (-inf,10) [10,20) [20,30) [30,+inf) + std::vector values = {5, 10, 15, 20, 25, 30, 35}; + std::vector boundaries = {10, 20, 30}; + std::vector expect = {0, 1, 1, 2, 2, 3, 3}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +TEST(ListIndexingTest, BucketizeLeftClosedRightOpen) { + // Element exactly equal to a boundary lands in the bucket starting at it + // (left-closed). Element just below stays in the previous bucket. + std::vector values = {9, 10, 11, 19, 20, 21}; + std::vector boundaries = {10, 20}; + // Layout: (-inf,10)=0, [10,20)=1, [20,+inf)=2 + std::vector expect = {0, 1, 1, 1, 2, 2}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +TEST(ListIndexingTest, BucketizeOutOfRangeFallsToEndBuckets) { + // Below min -> 0; at-or-above max -> len(boundaries). + std::vector values = {-1000, 0, 100, 1000}; + std::vector boundaries = {0, 100}; + // Layout: (-inf,0)=0, [0,100)=1, [100,+inf)=2 + std::vector expect = {0, 1, 2, 2}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +TEST(ListIndexingTest, BucketizeEmptyBoundaries) { + // No boundaries -> single (-inf,+inf) bucket -> everything is 0. + std::vector values = {-1, 0, 1, 2, 3}; + std::vector boundaries = {}; + std::vector expect = {0, 0, 0, 0, 0}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +TEST(ListIndexingTest, BucketizeEmptyValues) { + std::vector values = {}; + std::vector boundaries = {1.0, 2.0, 3.0}; + EXPECT_TRUE(RunBucketize(values, boundaries).empty()); +} + +TEST(ListIndexingTest, BucketizeFloat) { + // Verify floating-point ordering and a value sitting exactly on a boundary. + std::vector values = {0.5, 1.0, 1.5, 2.5, 3.5}; + std::vector boundaries = {1.0, 2.0, 3.0}; + std::vector expect = {0, 1, 1, 2, 3}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +TEST(ListIndexingTest, BucketizeNaNGoesToTopBucket) { + // NaN compares false against everything, so std::lower_bound walks past + // the end and the value is mapped to bucket = len(boundaries). Matches + // NumPy / PyTorch behaviour. + const double nan = std::numeric_limits::quiet_NaN(); + std::vector values = {nan, 1.5}; + std::vector boundaries = {1.0, 2.0}; + auto got = RunBucketize(values, boundaries); + ASSERT_EQ(got.size(), 2u); + EXPECT_EQ(got[0], 2u); // NaN -> top bucket + EXPECT_EQ(got[1], 1u); // 1.5 -> [1.0, 2.0) +} + +TEST(ListIndexingTest, BucketizeUnsigned) { + // Sanity check on an unsigned numeric type to confirm the template + // instantiates and registers correctly. + std::vector values = {0, 50, 100, 150, 200}; + std::vector boundaries = {100, 200}; + std::vector expect = {0, 0, 1, 1, 2}; + EXPECT_EQ(RunBucketize(values, boundaries), expect); +} + +// Internally Bucketize switches between a linear scan and std::upper_bound at +// kBucketizeLinearThreshold (=16). Verify both paths produce identical output +// across the threshold boundary, including for the value-equals-boundary case +// that distinguishes upper_bound from lower_bound. +TEST(ListIndexingTest, BucketizeLinearAndBinaryPathsAgree) { + // Build boundaries 10, 20, ..., 10*N and probe every interesting position: + // strictly below, exactly on, strictly between, exactly on the next, ... + auto build_case = [](int n_boundaries) { + std::vector boundaries; + boundaries.reserve(n_boundaries); + for (int i = 1; i <= n_boundaries; ++i) { + boundaries.push_back(i * 10); + } + std::vector values; + std::vector expect; + // below the smallest boundary + values.push_back(0); + expect.push_back(0); + for (int i = 0; i < n_boundaries; ++i) { + // exactly on the i-th boundary -> bucket i+1 (left-closed) + values.push_back(boundaries[i]); + expect.push_back(static_cast(i + 1)); + // strictly between b[i] and b[i+1] -> bucket i+1 + values.push_back(boundaries[i] + 5); + expect.push_back(static_cast(i + 1)); + } + // way above the top -> bucket n + values.push_back(10 * n_boundaries + 1000); + expect.push_back(static_cast(n_boundaries)); + return std::make_pair(std::move(values), std::pair{std::move(boundaries), std::move(expect)}); + }; + + // n=16: hits the linear scan path (last `<=` threshold value). + // n=17: hits the std::upper_bound path (first value above threshold). + // n=1 / n=2: tiny edge cases. + for (int n : {1, 2, 16, 17, 64}) { + auto [values, rest] = build_case(n); + auto& [boundaries, expect] = rest; + EXPECT_EQ(RunBucketize(values, boundaries), expect) << "n=" << n; + } +} From edbd0a0e237a470ee3459db24d1d1114b63c87bb Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 19:00:42 +0800 Subject: [PATCH 13/41] fix comment --- README.md | 2 +- include/exec_engine.h | 7 ++++++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/README.md b/README.md index c1fd3f2..2b5fabf 100644 --- a/README.md +++ b/README.md @@ -266,7 +266,7 @@ If you find that you have significant overhead in memory allocation, you can per Status Execute(ExecContext& exec_ctx, void* entry_arguments, void* result); ``` -Between two calls that reuse the same `ExecContext`, remember to invoke `exec_ctx.Clear()` — this resets the arena and clears any errors carried over from the previous call. +When you reuse the same `ExecContext` across multiple `Execute(ExecContext&, ...)` calls, you do **not** need to call `exec_ctx.Clear()` yourself — the engine resets the arena and clears any accumulated errors at the end of each call. As a consequence, any pointer returned via the arena (list / string payloads owned by the previous result) becomes invalid as soon as the next `Execute` returns; copy out anything you need to keep before issuing the next call. ## Engine options diff --git a/include/exec_engine.h b/include/exec_engine.h index 96566c4..52e78f4 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -28,7 +28,12 @@ namespace jitfusion { // ExecContext; a single ExecEngine can be shared by all of them after Compile(). // Within one thread, reusing an ExecContext across calls (via the // `Execute(ExecContext&, ...)` overloads) avoids re-allocating the arena on -// each call. +// each call. The engine resets the arena and clears the error list at the end +// of every Execute(ExecContext&, ...) call, so callers do NOT need to invoke +// Clear() manually between calls. As a consequence, any pointer returned +// through the arena (list / string payloads embedded in the previous result) +// becomes invalid as soon as the next Execute call returns — copy out anything +// you need to keep before issuing the next call. struct ExecContext { explicit ExecContext(int64_t alloc_min_chunk_size) : arena(alloc_min_chunk_size) {} Arena arena; From f24daecf107ea5bb13b1c987f7ea87036ef6f59c Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Wed, 6 May 2026 19:37:05 +0800 Subject: [PATCH 14/41] optimize scope_stack --- src/codegen/if_block_codegen.cc | 4 +--- src/scope_stack.h | 20 -------------------- src/validator.cc | 18 ++++++++---------- 3 files changed, 9 insertions(+), 33 deletions(-) diff --git a/src/codegen/if_block_codegen.cc b/src/codegen/if_block_codegen.cc index 9f49ee8..9599be2 100644 --- a/src/codegen/if_block_codegen.cc +++ b/src/codegen/if_block_codegen.cc @@ -20,8 +20,6 @@ Status CodeGen::Visit(IfBlockNode &if_block_node) { bool has_else = (num_args % 2 != 0); int num_branches = num_args / 2; - auto snapshot = scope_stack_.Snapshot(); - struct BranchInfo { llvm::BasicBlock *end_block; std::unordered_map modified; @@ -115,7 +113,7 @@ Status CodeGen::Visit(IfBlockNode &if_block_node) { } for (const auto &var_name : all_modified_vars) { - llvm::Value *original_value = snapshot[var_name]; + llvm::Value *original_value = scope_stack_.Lookup(var_name); llvm::PHINode *phi = ctx_.builder.CreatePHI(original_value->getType(), num_incoming, var_name + ".phi"); for (const auto &info : branch_infos) { auto it = info.modified.find(var_name); diff --git a/src/scope_stack.h b/src/scope_stack.h index 7d6ce5b..386c44f 100644 --- a/src/scope_stack.h +++ b/src/scope_stack.h @@ -23,16 +23,6 @@ class ScopeStack { void Set(const std::string& name, V value) { stack_.back()[name] = std::move(value); } - void SetOrUpdate(const std::string& name, V value) { - for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { - if (auto found = it->find(name); found != it->end()) { - found->second = std::move(value); - return; - } - } - stack_.back()[name] = std::move(value); - } - V Lookup(const std::string& name) const { for (auto it = stack_.rbegin(); it != stack_.rend(); ++it) { if (auto found = it->find(name); found != it->end()) { @@ -46,16 +36,6 @@ class ScopeStack { } } - std::unordered_map Snapshot() const { - std::unordered_map result; - for (const auto& scope : stack_) { - for (const auto& [name, value] : scope) { - result[name] = value; - } - } - return result; - } - std::unordered_map GetShadowed() const { std::unordered_map shadowed; for (const auto& [name, value] : stack_.back()) { diff --git a/src/validator.cc b/src/validator.cc index 950c3c7..1bf2b3a 100644 --- a/src/validator.cc +++ b/src/validator.cc @@ -383,8 +383,6 @@ Status Validator::Visit(IfBlockNode& if_block_node) { bool has_else = (num_args % 2 != 0); int num_branches = num_args / 2; - auto type_snapshot = type_scope_stack_.Snapshot(); - std::unordered_map all_shadowed; for (int i = 0; i < num_branches; ++i) { @@ -410,17 +408,17 @@ Status Validator::Visit(IfBlockNode& if_block_node) { TypeHelper::TypeToString(args[body_idx]->GetReturnType())); } auto shadowed = type_scope_stack_.GetShadowed(); + type_scope_stack_.PopScope(); for (const auto& [name, new_type] : shadowed) { - auto it = type_snapshot.find(name); - if (it != type_snapshot.end() && it->second != new_type) { + ValueType original_type = type_scope_stack_.Lookup(name); + if (original_type != ValueType::kUnknown && original_type != new_type) { return MakeParseError( if_block_node, "variable '" + name + "' has incompatible types across if block branches: original type is " + - TypeHelper::TypeToString(it->second) + ", but assigned " + TypeHelper::TypeToString(new_type)); + TypeHelper::TypeToString(original_type) + ", but assigned " + TypeHelper::TypeToString(new_type)); } all_shadowed[name] = new_type; } - type_scope_stack_.PopScope(); } if (has_else) { @@ -433,17 +431,17 @@ Status Validator::Visit(IfBlockNode& if_block_node) { TypeHelper::TypeToString(args[num_args - 1]->GetReturnType())); } auto shadowed = type_scope_stack_.GetShadowed(); + type_scope_stack_.PopScope(); for (const auto& [name, new_type] : shadowed) { - auto it = type_snapshot.find(name); - if (it != type_snapshot.end() && it->second != new_type) { + ValueType original_type = type_scope_stack_.Lookup(name); + if (original_type != ValueType::kUnknown && original_type != new_type) { return MakeParseError( if_block_node, "variable '" + name + "' has incompatible types across if block else branch: original type is " + - TypeHelper::TypeToString(it->second) + ", but assigned " + TypeHelper::TypeToString(new_type)); + TypeHelper::TypeToString(original_type) + ", but assigned " + TypeHelper::TypeToString(new_type)); } all_shadowed[name] = new_type; } - type_scope_stack_.PopScope(); } for (const auto& [name, type] : all_shadowed) { From 13a803dafed805cbd0010b50a3c319c9377d8f52 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 10:26:08 +0800 Subject: [PATCH 15/41] in function change to exact match --- src/function/list_basic.cc | 24 ++++-------------------- 1 file changed, 4 insertions(+), 20 deletions(-) diff --git a/src/function/list_basic.cc b/src/function/list_basic.cc index 427d036..6560267 100644 --- a/src/function/list_basic.cc +++ b/src/function/list_basic.cc @@ -37,28 +37,12 @@ ListType ListConcat(ListType a, ListType b, void *exec_context) { template uint8_t IsInList(typename ListType::CElementType a, ListType b) { - if constexpr (std::is_same_v) { - for (std::size_t i = 0; i < b.len; ++i) { - if (std::abs(a - b.data[i]) < std::numeric_limits::epsilon()) { - return 1; - } - } - return 0; - } else if constexpr (std::is_same_v) { - for (std::size_t i = 0; i < b.len; ++i) { - if (std::abs(a - b.data[i]) < std::numeric_limits::epsilon()) { - return 1; - } - } - return 0; - } else { - for (std::size_t i = 0; i < b.len; ++i) { - if (a == b.data[i]) { - return 1; - } + for (std::size_t i = 0; i < b.len; ++i) { + if (a == b.data[i]) { + return 1; } - return 0; } + return 0; } inline uint8_t IsInStringList(StringStruct a, StringListStruct b) { From 42fc271dca996f109a608e20182948499c30175a Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 14:30:30 +0800 Subject: [PATCH 16/41] const list type and const string type optimize with llvm::constant type --- include/exec_engine.h | 10 +- include/function_registry.h | 11 +- src/codegen/const_global_emit.cc | 118 ++++++++++++++ src/codegen/const_global_emit.h | 28 ++++ src/codegen/const_list_value_codegen.cc | 61 ++++--- src/codegen/const_value_codegen.cc | 19 +-- src/exec_engine.cc | 12 +- test/relocatable_const_test.cc | 203 ++++++++++++++++++++++++ 8 files changed, 404 insertions(+), 58 deletions(-) create mode 100644 src/codegen/const_global_emit.cc create mode 100644 src/codegen/const_global_emit.h create mode 100644 test/relocatable_const_test.cc diff --git a/include/exec_engine.h b/include/exec_engine.h index 52e78f4..2a263be 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -85,6 +85,15 @@ enum class FPMathMode : std::uint8_t { }; struct ExecEngineOption { + // DEPRECATED since relocatable constant globals landed: constant + // list / string payloads now live as Module-level GlobalVariables + // (private, unnamed_addr, constant) instead of being copied into an + // engine-owned Arena and referenced via `inttoptr `. This + // field is therefore unused and exists only to preserve aggregate + // initialization ordering for users who wrote + // `ExecEngineOption{a, b, dump_ir, fp}`; it will be removed in a + // future major version. + [[deprecated("Constant payloads are now emitted as Module-level globals; this field is ignored.")]] int64_t const_value_arena_alloc_min_chunk_size{4096}; int64_t exec_ctx_arena_alloc_min_chunk_size{4096}; // If true, the fully optimized LLVM IR text will be captured during Compile and made available via GetIRCode(). @@ -160,7 +169,6 @@ class ExecEngine { void ResetCompiledState(); - Arena const_value_arena_; std::unique_ptr jit_; char* entry_func_ptr_; ValueType ret_type_; diff --git a/include/function_registry.h b/include/function_registry.h index a83a613..2ba36d4 100644 --- a/include/function_registry.h +++ b/include/function_registry.h @@ -2,15 +2,15 @@ * @Author: victorika * @Date: 2025-01-15 15:47:48 * @Last Modified by: victorika - * @Last Modified time: 2025-03-04 19:02:45 + * @Last Modified time: 2026-05-07 14:25:38 */ #pragma once #include #include +#include #include #include -#include "arena.h" #include "llvm/ExecutionEngine/Orc/LLJIT.h" #include "llvm/IR/Attributes.h" #include "llvm/IR/BasicBlock.h" @@ -55,14 +55,13 @@ constexpr const char *kCommutative = "commutative"; struct IRCodeGenContext { IRCodeGenContext(llvm::LLVMContext &context, llvm::Module &module, llvm::IRBuilder<> &builder, llvm::Function *entry_function, LLVMStructType complex_type, - const std::unique_ptr &function_registry, Arena &const_value_arena) + const std::unique_ptr &function_registry) : context(context), module(module), builder(builder), entry_function(entry_function), complex_type(complex_type), - function_registry(function_registry), - const_value_arena(const_value_arena) {} + function_registry(function_registry) {} llvm::LLVMContext &context; llvm::Module &module; @@ -70,8 +69,8 @@ struct IRCodeGenContext { llvm::Function *entry_function; LLVMStructType complex_type; std::map const_list_cache; + std::map const_string_cache; const std::unique_ptr &function_registry; - Arena &const_value_arena; }; using CodeGenFunc = std::function &, diff --git a/src/codegen/const_global_emit.cc b/src/codegen/const_global_emit.cc new file mode 100644 index 0000000..bb6506c --- /dev/null +++ b/src/codegen/const_global_emit.cc @@ -0,0 +1,118 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 14:19:55 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 14:25:09 + */ +#include "codegen/const_global_emit.h" + +#include +#include +#include "llvm/ADT/ArrayRef.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/DerivedTypes.h" +#include "llvm/IR/GlobalValue.h" +#include "llvm/IR/GlobalVariable.h" +#include "llvm/IR/Module.h" +#include "llvm/IR/Type.h" + +namespace jitfusion { + +namespace { + +llvm::GlobalVariable *CreatePrivateGlobal(llvm::Module &m, llvm::Constant *init, llvm::StringRef name_hint, + unsigned alignment) { + auto *gv = new llvm::GlobalVariable(m, init->getType(), /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, init, + name_hint); + gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); + if (alignment > 0) { + gv->setAlignment(llvm::Align(alignment)); + } + return gv; +} + +llvm::Constant *AnchorArrayInGlobal(IRCodeGenContext &ctx, llvm::Constant *init, std::size_t alignment) { + auto *gv = CreatePrivateGlobal(ctx.module, init, "jf.arr", static_cast(alignment == 0 ? 1 : alignment)); + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + return llvm::ConstantExpr::getInBoundsGetElementPtr( + gv->getValueType(), gv, + llvm::ArrayRef{llvm::ConstantInt::get(i32_ty, 0), llvm::ConstantInt::get(i32_ty, 0)}); +} + +llvm::Constant *NullIfEmpty(IRCodeGenContext &ctx, std::size_t n) { + if (n == 0) { + return llvm::ConstantPointerNull::get(llvm::PointerType::getUnqual(ctx.context)); + } + return nullptr; +} + +} // namespace + +llvm::Constant *EmitStringPayloadGlobal(IRCodeGenContext &ctx, const std::string &s) { + auto *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + if (s.empty()) { + return llvm::ConstantPointerNull::get(ptr_ty); + } + + if (auto it = ctx.const_string_cache.find(s); it != ctx.const_string_cache.end()) { + return it->second; + } + + auto *init = llvm::ConstantDataArray::get( + ctx.context, llvm::ArrayRef(reinterpret_cast(s.data()), s.size())); + auto *gv = CreatePrivateGlobal(ctx.module, init, "jf.str", /*alignment=*/1); + auto *gep = llvm::ConstantExpr::getInBoundsGetElementPtr( + gv->getValueType(), gv, + llvm::ArrayRef{llvm::ConstantInt::get(llvm::Type::getInt32Ty(ctx.context), 0), + llvm::ConstantInt::get(llvm::Type::getInt32Ty(ctx.context), 0)}); + ctx.const_string_cache.emplace(s, gep); + return gep; +} + +template +llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &ctx, llvm::ArrayRef data, std::size_t alignment) { + static_assert(std::is_same_v || std::is_same_v || + std::is_same_v || std::is_same_v || + std::is_same_v || std::is_same_v || + std::is_same_v || std::is_same_v || + std::is_same_v || std::is_same_v, + "EmitTypedArrayGlobal: ElemT must match one of the " + "ConstantDataArray::get() specializations (i8/i16/i32/i64 integer " + "widths, signed or unsigned, plus float/double)."); + + if (auto *null_c = NullIfEmpty(ctx, data.size())) { + return null_c; + } + auto *init = llvm::ConstantDataArray::get(ctx.context, data); + return AnchorArrayInGlobal(ctx, init, alignment); +} + +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, + std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, std::size_t); +template llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &, llvm::ArrayRef, std::size_t); + +llvm::Constant *BuildPtrLenStructConstant(IRCodeGenContext &ctx, llvm::StructType *struct_type, + llvm::Constant *data_ptr, uint32_t len) { + auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); + auto *len_c = llvm::ConstantInt::get(i32_ty, len, /*isSigned=*/false); + assert(struct_type->getNumElements() == 2 && "PtrLen struct must have exactly 2 fields"); + return llvm::ConstantStruct::get(struct_type, {data_ptr, len_c}); +} + +} // namespace jitfusion diff --git a/src/codegen/const_global_emit.h b/src/codegen/const_global_emit.h new file mode 100644 index 0000000..47ec16c --- /dev/null +++ b/src/codegen/const_global_emit.h @@ -0,0 +1,28 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 14:19:50 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 14:20:53 + */ + +#pragma once + +#include +#include +#include +#include "function_registry.h" +#include "llvm/ADT/ArrayRef.h" +#include "llvm/IR/Constant.h" +#include "llvm/IR/GlobalVariable.h" + +namespace jitfusion { + +llvm::Constant *EmitStringPayloadGlobal(IRCodeGenContext &ctx, const std::string &s); + +template +llvm::Constant *EmitTypedArrayGlobal(IRCodeGenContext &ctx, llvm::ArrayRef data, std::size_t alignment); + +llvm::Constant *BuildPtrLenStructConstant(IRCodeGenContext &ctx, llvm::StructType *struct_type, + llvm::Constant *data_ptr, uint32_t len); + +} // namespace jitfusion diff --git a/src/codegen/const_list_value_codegen.cc b/src/codegen/const_list_value_codegen.cc index e2d602e..01f909e 100644 --- a/src/codegen/const_list_value_codegen.cc +++ b/src/codegen/const_list_value_codegen.cc @@ -2,9 +2,11 @@ * @Author: victorika * @Date: 2025-01-21 16:16:20 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 16:07:20 + * @Last Modified time: 2026-05-07 14:26:54 */ #include "codegen.h" +#include "codegen/const_global_emit.h" +#include "llvm/IR/Constants.h" #include "llvm/IR/DerivedTypes.h" namespace jitfusion { @@ -15,40 +17,37 @@ struct MakeListVisitor { IRCodeGenContext &ctx_; llvm::Value *operator()(const std::vector &list) const { - StringStruct *data = nullptr; - if (!list.empty()) { - data = reinterpret_cast(ctx_.const_value_arena.Allocate(list.size() * sizeof(StringStruct))); - for (std::size_t idx = 0; idx < list.size(); ++idx) { - if (list[idx].empty()) { - data[idx].data = nullptr; - } else { - data[idx].data = reinterpret_cast(ctx_.const_value_arena.Allocate(list[idx].size())); - memcpy(data[idx].data, list[idx].data(), list[idx].size() * sizeof(char)); - } - data[idx].len = list[idx].size(); - } + if (list.empty()) { + auto *ptr_ty = llvm::PointerType::getUnqual(ctx_.context); + return BuildPtrLenStructConstant(ctx_, ctx_.complex_type.stringlist_type, llvm::ConstantPointerNull::get(ptr_ty), + 0U); } - return EmitPtrLenStruct(data, list.size(), ctx_.complex_type.stringlist_type); - } - template - llvm::Value *CreateNumberList(const std::vector &list, llvm::StructType *struct_type) const { - void *data = nullptr; - if (!list.empty()) { - data = ctx_.const_value_arena.Allocate(list.size() * sizeof(ValueType)); - memcpy(data, list.data(), list.size() * sizeof(ValueType)); + auto *elem_struct_ty = ctx_.complex_type.string_type; + std::vector elems; + elems.reserve(list.size()); + for (const auto &s : list) { + llvm::Constant *payload_ptr = EmitStringPayloadGlobal(ctx_, s); + elems.emplace_back(BuildPtrLenStructConstant(ctx_, elem_struct_ty, payload_ptr, static_cast(s.size()))); } - return EmitPtrLenStruct(data, list.size(), struct_type); + auto *arr_ty = llvm::ArrayType::get(elem_struct_ty, elems.size()); + auto *arr_init = llvm::ConstantArray::get(arr_ty, elems); + auto *gv = new llvm::GlobalVariable(ctx_.module, arr_ty, /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, + arr_init, "jf.strlist"); + gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); + gv->setAlignment(llvm::Align(alignof(void *))); + auto *i32_ty = llvm::Type::getInt32Ty(ctx_.context); + auto *gep = llvm::ConstantExpr::getInBoundsGetElementPtr( + arr_ty, gv, + llvm::ArrayRef{llvm::ConstantInt::get(i32_ty, 0), llvm::ConstantInt::get(i32_ty, 0)}); + return BuildPtrLenStructConstant(ctx_, ctx_.complex_type.stringlist_type, gep, static_cast(list.size())); } - llvm::Value *EmitPtrLenStruct(const void *data, std::size_t len, llvm::StructType *struct_type) const { - auto &builder = ctx_.builder; - llvm::Value *data_ptr = builder.CreateIntToPtr(builder.getInt64(reinterpret_cast(data)), - llvm::PointerType::getUnqual(ctx_.context)); - llvm::Value *ret = llvm::UndefValue::get(struct_type); - ret = builder.CreateInsertValue(ret, data_ptr, 0); - ret = builder.CreateInsertValue(ret, builder.getInt32(len), 1); - return ret; + template + llvm::Value *CreateNumberList(const std::vector &list, llvm::StructType *struct_type) const { + llvm::Constant *data_ptr = + EmitTypedArrayGlobal(ctx_, llvm::ArrayRef(list.data(), list.size()), alignof(ElemType)); + return BuildPtrLenStructConstant(ctx_, struct_type, data_ptr, static_cast(list.size())); } llvm::Value *operator()(const std::vector &list) const { @@ -97,4 +96,4 @@ Status CodeGen::Visit(ConstantListValueNode &list_node) { return Status::OK(); } -} // namespace jitfusion \ No newline at end of file +} // namespace jitfusion diff --git a/src/codegen/const_value_codegen.cc b/src/codegen/const_value_codegen.cc index 296600b..3ecf1fd 100644 --- a/src/codegen/const_value_codegen.cc +++ b/src/codegen/const_value_codegen.cc @@ -2,9 +2,12 @@ * @Author: victorika * @Date: 2025-01-21 10:38:03 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 16:12:57 + * @Last Modified time: 2026-05-07 14:23:50 */ #include "codegen.h" +#include "codegen/const_global_emit.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/GlobalVariable.h" #include "llvm/IR/Type.h" namespace jitfusion { @@ -49,18 +52,8 @@ struct MakeValueVisitor { llvm::Value *operator()(double v) const { return llvm::ConstantFP::get(llvm::Type::getDoubleTy(ctx_.context), v); } llvm::Value *operator()(const std::string &v) const { - char *str = nullptr; - if (!v.empty()) { - str = reinterpret_cast(ctx_.const_value_arena.Allocate(v.size())); - memcpy(str, v.c_str(), v.size()); - } - auto &builder = ctx_.builder; - llvm::Value *str_ptr = builder.CreateIntToPtr(builder.getInt64(reinterpret_cast(str)), - llvm::PointerType::getUnqual(ctx_.context)); - llvm::Value *ret = llvm::UndefValue::get(ctx_.complex_type.string_type); - ret = builder.CreateInsertValue(ret, str_ptr, 0); - ret = builder.CreateInsertValue(ret, builder.getInt32(v.size()), 1); - return ret; + llvm::Constant *data_ptr = EmitStringPayloadGlobal(ctx_, v); + return BuildPtrLenStructConstant(ctx_, ctx_.complex_type.string_type, data_ptr, static_cast(v.size())); } }; diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 2039153..3e48962 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -193,7 +193,7 @@ struct CommutativeCallCanonicalizerPass : public llvm::PassInfoMixin& owner, const LLVMStructType& llvm_struct_type, const std::string& func_name, ValueType ret_type, const std::unique_ptr& exec_node, - const std::unique_ptr& func_registry, Arena& const_value_arena_) { + const std::unique_ptr& func_registry) { llvm::FunctionCallee entry_func_callee; JF_RETURN_NOT_OK( GetEntryFunctionCallee(llvm_context, owner, llvm_struct_type, func_name, ret_type, &entry_func_callee)); @@ -208,7 +208,7 @@ Status BuildEntryFunction(llvm::LLVMContext& llvm_context, std::unique_ptr builder(entry_bb); std::unique_ptr codegen_ctx = std::make_unique( - llvm_context, *owner, builder, entry_function, llvm_struct_type, func_registry, const_value_arena_); + llvm_context, *owner, builder, entry_function, llvm_struct_type, func_registry); CodeGen codegen(*codegen_ctx); @@ -248,15 +248,13 @@ using return_stringlist_function_type = StringListStruct (*)(void*, void*, void* } // namespace -ExecEngine::ExecEngine(ExecEngineOption option) - : const_value_arena_(option.const_value_arena_alloc_min_chunk_size), option_(option) {} +ExecEngine::ExecEngine(ExecEngineOption option) : option_(option) {} void ExecEngine::ResetCompiledState() { jit_.reset(); batch_entry_func_ptrs_.clear(); batch_ret_types_.clear(); ir_code_.clear(); - const_value_arena_.Reset(); } Status ExecEngine::Compile(const std::unique_ptr& exec_node, @@ -274,7 +272,7 @@ Status ExecEngine::Compile(const std::unique_ptr& exec_node, LLVMStructType llvm_struct_type = CreateLLVMStructType(*llvm_context); JF_RETURN_NOT_OK(BuildEntryFunction(*llvm_context, owner, llvm_struct_type, kEntryFunctionName, ret_type_, exec_node, - func_registry, const_value_arena_)); + func_registry)); JF_RETURN_NOT_OK(func_registry->SetCFuncAttr(owner.get())); // verify @@ -464,7 +462,7 @@ Status ExecEngine::BatchCompile(const std::vector>& ex batch_ret_types_[i] = node_ret_type; JF_RETURN_NOT_OK(BuildEntryFunction(*llvm_context, owner, llvm_struct_type, func_name, node_ret_type, exec_nodes[i], - func_registry, const_value_arena_)); + func_registry)); func_names[i] = std::move(func_name); } JF_RETURN_NOT_OK(func_registry->SetCFuncAttr(owner.get())); diff --git a/test/relocatable_const_test.cc b/test/relocatable_const_test.cc new file mode 100644 index 0000000..5faa925 --- /dev/null +++ b/test/relocatable_const_test.cc @@ -0,0 +1,203 @@ +/* + * Regression tests for the "relocatable constants" refactor. + * + * Goal: guarantee that the LLVM Module produced by Compile() / + * BatchCompile() never embeds absolute host addresses for constant + * string / list payloads. Such addresses would manifest as + * `inttoptr (i64 to ptr)` in the IR dump and would + * make the module unusable across processes — which is the foundation + * a future ObjectCache layer depends on. + * + * We check two invariants on the dumped, fully-optimized IR: + * 1. It contains at least one private unnamed_addr constant global + * carrying the constant payload (proving the new emission path + * actually runs). + * 2. It contains no `inttoptr` form with a nonzero host address + * pointing into the current process. We allow `inttoptr i64 0` + * because the null pointer is a legitimate constant encoding + * for empty string/list. + */ +#include +#include +#include +#include +#include +#include "exec_engine.h" +#include "exec_node.h" +#include "function_registry.h" +#include "gtest/gtest.h" +#include "type.h" + +using namespace jitfusion; + +namespace { + +// Returns true if `ir` contains any `inttoptr` whose integer operand is +// a nonzero literal. This matches both the legacy form +// `inttoptr (i64 12345 to ptr)` and the `inttoptr i64 12345 to ptr` +// instruction form. `inttoptr i64 0 to ptr` is explicitly treated as +// acceptable (that is how LLVM spells an empty StringStruct/ListStruct +// data pointer in our encoding, and it is trivially relocatable). +bool HasNonzeroInttoptr(const std::string& ir) { + // The regex is intentionally permissive about spacing and the + // optional surrounding parentheses because LLVM's printer is + // inconsistent between ConstantExpr and Instruction forms. + std::regex re(R"(inttoptr\s*\(?\s*i(?:8|16|32|64)\s+(-?\d+))"); + auto begin = std::sregex_iterator(ir.begin(), ir.end(), re); + auto end = std::sregex_iterator(); + for (auto it = begin; it != end; ++it) { + const std::string& num = (*it)[1]; + if (num != "0") { + return true; + } + } + return false; +} + +bool HasPrivateConstantGlobal(const std::string& ir) { + // The globals emitted by EmitStringPayloadGlobal / EmitRawBytesGlobal + // share the "jf." name prefix and always have private+constant + // linkage. Post-optimization LLVM may rename (e.g. jf.str.1) and may + // inline some into `.rodata` merged constants, but at least one of + // the shapes below should survive for any non-trivial constant. + return ir.find("private unnamed_addr constant") != std::string::npos || + ir.find("internal unnamed_addr constant") != std::string::npos; +} + +ExecEngineOption DumpIROpt() { + ExecEngineOption opt; + opt.dump_ir = true; + return opt; +} + +} // namespace + +TEST(RelocatableConstTest, StringLiteralUsesGlobal) { + std::unique_ptr reg; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + + const std::string literal = "hello_relocatable_world"; + auto node = std::unique_ptr(new ConstantValueNode(literal)); + + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + + std::string ir(engine.GetIRCode()); + ASSERT_FALSE(ir.empty()); + EXPECT_TRUE(HasPrivateConstantGlobal(ir)) << "IR should contain a private constant global for the string payload:\n" + << ir; + EXPECT_FALSE(HasNonzeroInttoptr(ir)) + << "IR still embeds an absolute host address via `inttoptr`; the module is not relocatable:\n" + << ir; + + // And the runtime semantics must not regress. + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get(result), literal); +} + +TEST(RelocatableConstTest, NumericListUsesGlobal) { + std::unique_ptr reg; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + + std::vector data = {1, 2, 3, 4, 5, 6, 7, 8}; + auto node = std::unique_ptr(new ConstantListValueNode(data)); + + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + + std::string ir(engine.GetIRCode()); + ASSERT_FALSE(ir.empty()); + EXPECT_TRUE(HasPrivateConstantGlobal(ir)) << ir; + EXPECT_FALSE(HasNonzeroInttoptr(ir)) << ir; + + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get>(result), data); +} + +TEST(RelocatableConstTest, StringListUsesGlobal) { + std::unique_ptr reg; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + + std::vector data = {"alpha", "beta", "", "gamma_with_more_bytes"}; + auto node = std::unique_ptr(new ConstantListValueNode(data)); + + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + + std::string ir(engine.GetIRCode()); + ASSERT_FALSE(ir.empty()); + EXPECT_TRUE(HasPrivateConstantGlobal(ir)) << ir; + EXPECT_FALSE(HasNonzeroInttoptr(ir)) << ir; + + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get>(result), data); +} + +TEST(RelocatableConstTest, EmptyStringAndEmptyListStillWork) { + // Empty payloads intentionally serialize to {data=null, len=0}, + // which shows up as `inttoptr i64 0` or just `ptr null` in IR. + // Both forms are relocatable; this test guards the corner case. + std::unique_ptr reg; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + + { + auto node = std::unique_ptr(new ConstantValueNode(std::string{})); + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + EXPECT_FALSE(HasNonzeroInttoptr(std::string(engine.GetIRCode()))); + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get(result), ""); + } + { + auto node = std::unique_ptr(new ConstantListValueNode(std::vector{})); + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + EXPECT_FALSE(HasNonzeroInttoptr(std::string(engine.GetIRCode()))); + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get>(result), std::vector{}); + } + { + auto node = std::unique_ptr(new ConstantListValueNode(std::vector{})); + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + EXPECT_FALSE(HasNonzeroInttoptr(std::string(engine.GetIRCode()))); + RetType result; + ASSERT_TRUE(engine.Execute(nullptr, &result).ok()); + EXPECT_EQ(std::get>(result), std::vector{}); + } +} + +TEST(RelocatableConstTest, DuplicateLiteralIsDeduped) { + // Two identical string literals in the same Module should share the + // same underlying payload global (const_string_cache hit). We can't + // directly inspect the LLVM module from here, but we can check that + // the IR still only contains a single "jf.str" style global for the + // repeated payload — i.e. the dedup cache is actually used. + std::unique_ptr reg; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + + std::vector data = {"repeat_me", "repeat_me", "repeat_me"}; + auto node = std::unique_ptr(new ConstantListValueNode(data)); + + ExecEngine engine(DumpIROpt()); + ASSERT_TRUE(engine.Compile(node, reg).ok()); + + std::string ir(engine.GetIRCode()); + ASSERT_FALSE(ir.empty()); + // The payload "repeat_me" is 9 bytes; after dedup there should be + // exactly one `[9 x i8]` ConstantDataArray initializer carrying it. + // We search for the literal byte string form that LLVM prints for + // ConstantDataArray (`c"repeat_me"`). Post-O3, LLVM may sink this + // into a .rodata merge but will not duplicate byte-identical + // constants. + std::regex re(R"(c\"repeat_me\")"); + auto begin = std::sregex_iterator(ir.begin(), ir.end(), re); + auto end = std::sregex_iterator(); + const auto count = std::distance(begin, end); + EXPECT_EQ(count, 1) << "Expected exactly 1 occurrence of the payload literal in IR, got " << count << ":\n" << ir; +} From 9bb275e6083d794bda0fe4c037ef099f7741d85f Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 14:34:23 +0800 Subject: [PATCH 17/41] remove useless option --- README.md | 1 - include/exec_engine.h | 10 ---------- 2 files changed, 11 deletions(-) diff --git a/README.md b/README.md index 2b5fabf..b7ba02e 100644 --- a/README.md +++ b/README.md @@ -274,7 +274,6 @@ When you reuse the same `ExecContext` across multiple `Execute(ExecContext&, ... | Field | Default | Purpose | | --- | --- | --- | -| `const_value_arena_alloc_min_chunk_size` | `4096` | Minimum chunk size (in bytes) for the engine-owned arena that backs constant values embedded in the IR. Raise it if you embed large constant lists / strings and want to avoid chunk churn during compilation. | | `exec_ctx_arena_alloc_min_chunk_size` | `4096` | Minimum chunk size for the per-execution arena created when you call an `Execute*` overload that does **not** take an explicit `ExecContext`. Ignored for the `ExecContext&` overloads (the caller owns the arena). | | `dump_ir` | `false` | When `true`, the fully optimized LLVM IR text is captured during `Compile` / `BatchCompile` and made available via `GetIRCode()`. Useful for debugging; avoid enabling in production because serializing a large Module to text is expensive. | | `fp_math_mode` | `FPMathMode::kFast` | Floating-point semantics requested from the JIT backend. `kFast` enables FMA fusion and `-ffast-math`-style algebraic rewrites (1.3x - 2x faster on FP-heavy list kernels). Switch to `kStrict` if you need bit-for-bit IEEE-754 reproducibility (finance / risk / regression tests). | diff --git a/include/exec_engine.h b/include/exec_engine.h index 2a263be..def2011 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -85,16 +85,6 @@ enum class FPMathMode : std::uint8_t { }; struct ExecEngineOption { - // DEPRECATED since relocatable constant globals landed: constant - // list / string payloads now live as Module-level GlobalVariables - // (private, unnamed_addr, constant) instead of being copied into an - // engine-owned Arena and referenced via `inttoptr `. This - // field is therefore unused and exists only to preserve aggregate - // initialization ordering for users who wrote - // `ExecEngineOption{a, b, dump_ir, fp}`; it will be removed in a - // future major version. - [[deprecated("Constant payloads are now emitted as Module-level globals; this field is ignored.")]] - int64_t const_value_arena_alloc_min_chunk_size{4096}; int64_t exec_ctx_arena_alloc_min_chunk_size{4096}; // If true, the fully optimized LLVM IR text will be captured during Compile and made available via GetIRCode(). // Mainly for debugging: serializing a large Module to text is expensive (can be hundreds of KB and requires a From ee6130125f80094a788e63e7833ad23e2e0b6881 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 16:44:40 +0800 Subject: [PATCH 18/41] engine support save and load --- include/exec_engine.h | 68 +++++++- src/compiled_artifact.cc | 308 +++++++++++++++++++++++++++++++++ src/compiled_artifact.h | 179 ++++++++++++++++++++ src/exec_engine.cc | 145 +++++++++++++++- test/save_load_test.cc | 358 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 1056 insertions(+), 2 deletions(-) create mode 100644 src/compiled_artifact.cc create mode 100644 src/compiled_artifact.h create mode 100644 test/save_load_test.cc diff --git a/include/exec_engine.h b/include/exec_engine.h index def2011..e3eb905 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 10:48:46 * @Last Modified by: victorika - * @Last Modified time: 2026-03-31 14:45:31 + * @Last Modified time: 2026-05-07 16:08:44 */ #pragma once @@ -93,6 +93,23 @@ struct ExecEngineOption { // See FPMathMode above. Default stays kFast so that existing users' // observed numeric behavior does not change when they upgrade. FPMathMode fp_math_mode{FPMathMode::kFast}; + // If true, the raw compiled object bytes are captured during + // Compile() / BatchCompile() and retained in the engine so that + // SaveCompiled() can serialize them afterwards. Defaults to false + // because capturing costs one memcpy and ~KBs-to-MBs of extra + // resident memory per engine — pure waste for users who never + // persist compiled artifacts. + // + // Note on lifecycle: the captured bytes are released by the next + // Compile()/BatchCompile() (via ResetCompiledState) or when the + // engine is destroyed. There is deliberately no "release now" API: + // SaveCompiled may legitimately be called multiple times, so the + // engine keeps the bytes as long as the compilation is live. + // + // Must be set before Compile()/BatchCompile(); flipping it after + // the fact does NOT retroactively materialize bytes for an already- + // compiled engine — you would need to re-Compile(). + bool enable_save_compiled{false}; }; // Thread-safety contract: @@ -153,6 +170,49 @@ class ExecEngine { [[nodiscard]] std::string_view GetIRCode() const { return ir_code_; } + // ------------------------------------------------------------------------- + // Compiled-artifact persistence (serialize / deserialize). + // + // After a successful Compile() / BatchCompile(), SaveCompiled() packs the + // JIT-produced relocatable object file plus a small header (engine mode, + // return type(s), target triple, LLVM version, FP mode, ...) into a + // self-contained byte string. LoadCompiled() is an alternative entry point + // to Compile() that takes such a byte string and a FunctionRegistry and + // restores the engine into a state indistinguishable from a fresh Compile() + // — i.e. all Execute* overloads work identically afterwards. + // + // This pair exists so that callers who already have a way to persist bytes + // (disk, KV store, network cache) can skip the most expensive parts of + // Compile(): IR construction, the O3 pipeline, and backend codegen. A + // successful LoadCompiled typically runs in single-digit milliseconds + // where Compile() takes tens to hundreds. + // + // Compatibility contract: + // * A blob saved with one LLVM version / target / CPU can ONLY be loaded + // by a process with the matching LLVM version / target / CPU. Mismatches + // are detected and rejected cleanly (Status::InvalidArgument) rather + // than miscompiled silently. + // * The FunctionRegistry passed to LoadCompiled must register every C + // function referenced by the original ExecNode tree under the same + // FunctionSignature. Addresses may differ across processes (that's the + // whole point of relocatable globals), but names + param/ret types + // must match. Missing symbols surface as lookup failures on first + // Execute*. + // * IR dump (GetIRCode()) is NOT populated after LoadCompiled, because + // the IR is never constructed. This is intentional — getting the IR + // back would require re-running codegen, defeating the purpose. + // + // SaveCompiled() is only valid immediately after a successful Compile() / + // BatchCompile() that ran with ExecEngineOption::enable_save_compiled=true. + // It will also fail on a default-constructed or load-restored engine, + // because in those cases the engine never captured object bytes to begin + // with. The opt-in is deliberate: capturing costs one memcpy of the .o + // file (a few KB to a few MB depending on pipeline size), plus the same + // again in resident memory until the engine is destroyed or re-compiled, + // which is pure overhead for users who never persist artifacts. + Status SaveCompiled(std::string* out) const; + Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry); + private: Status CreateJitAndOptimize(const std::unique_ptr& func_registry, std::unique_ptr owner, std::unique_ptr llvm_context); @@ -166,6 +226,12 @@ class ExecEngine { std::string ir_code_; std::vector batch_entry_func_ptrs_; std::vector batch_ret_types_; + // Raw object bytes captured during Compile/BatchCompile. Non-empty only + // when the engine produced them itself (we need the bytes to implement + // SaveCompiled). Filled in by a hook installed on the IRCompileLayer in + // CreateJitAndOptimize. + // + std::string compiled_object_bytes_; }; } // namespace jitfusion \ No newline at end of file diff --git a/src/compiled_artifact.cc b/src/compiled_artifact.cc new file mode 100644 index 0000000..5de4544 --- /dev/null +++ b/src/compiled_artifact.cc @@ -0,0 +1,308 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 16:14:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 16:18:56 + */ +#include "compiled_artifact.h" + +#include +#include +#include + +namespace jitfusion { + +namespace { + +// Magic numbers at the head and tail of every artifact. The tail is +// not strictly required for parsing correctness (lengths inside the +// blob are explicit), but it is a cheap way to detect truncation that +// happens to leave a "coincidentally plausible" length prefix before +// the cut. +constexpr std::array kArtifactMagic{'J', 'F', 'C', 'A'}; +constexpr std::array kArtifactFooterMagic{'J', 'F', 'C', 'E'}; + +// --------------------------------------------------------------------------- +// Little-endian write helpers. +// +// We deliberately do NOT use memcpy of native ints. Reasons: +// 1. The artifact is a wire format; explicit byte-by-byte assembly +// documents the layout at the code level and makes a big-endian +// host (hypothetical, not supported today) trivially correct. +// 2. The modern compilers we target recognize this pattern and lower +// it to a single store on little-endian hosts, so there is no +// measurable runtime cost. +// --------------------------------------------------------------------------- +void AppendU8(std::string& out, std::uint8_t v) { out.push_back(static_cast(v)); } + +void AppendU32LE(std::string& out, std::uint32_t v) { + for (int i = 0; i < 4; ++i) { + out.push_back(static_cast((v >> (i * 8)) & 0xff)); + } +} + +void AppendU64LE(std::string& out, std::uint64_t v) { + for (int i = 0; i < 8; ++i) { + out.push_back(static_cast((v >> (i * 8)) & 0xff)); + } +} + +void AppendLenPrefixedStr(std::string& out, std::string_view s) { + AppendU32LE(out, static_cast(s.size())); + out.append(s.data(), s.size()); +} + +void AppendBytes(std::string& out, const char* data, std::size_t n) { out.append(data, n); } + +// --------------------------------------------------------------------------- +// Cursor-style reader. +// +// All Read* methods return Status so that a malformed blob surfaces a +// single precise error via JF_RETURN_NOT_OK rather than crashing on +// out-of-bounds access. The cursor (pos_) only advances on success, so +// error messages can report the offset at which parsing stopped. +// --------------------------------------------------------------------------- +class ArtifactReader { + public: + explicit ArtifactReader(std::string_view buf) : buf_(buf), pos_(0) {} + + Status ReadU8(std::uint8_t* out) { + if (pos_ + 1 > buf_.size()) { + return Status::InvalidArgument("compiled artifact: unexpected EOF reading u8 at offset ", pos_); + } + *out = static_cast(buf_[pos_++]); + return Status::OK(); + } + + Status ReadU32LE(std::uint32_t* out) { + if (pos_ + 4 > buf_.size()) { + return Status::InvalidArgument("compiled artifact: unexpected EOF reading u32 at offset ", pos_); + } + std::uint32_t v = 0; + for (int i = 0; i < 4; ++i) { + v |= static_cast(static_cast(buf_[pos_ + i])) << (i * 8); + } + pos_ += 4; + *out = v; + return Status::OK(); + } + + Status ReadU64LE(std::uint64_t* out) { + if (pos_ + 8 > buf_.size()) { + return Status::InvalidArgument("compiled artifact: unexpected EOF reading u64 at offset ", pos_); + } + std::uint64_t v = 0; + for (int i = 0; i < 8; ++i) { + v |= static_cast(static_cast(buf_[pos_ + i])) << (i * 8); + } + pos_ += 8; + *out = v; + return Status::OK(); + } + + Status ReadLenPrefixedStr(std::string* out) { + std::uint32_t len = 0; + JF_RETURN_NOT_OK(ReadU32LE(&len)); + if (pos_ + len > buf_.size()) { + return Status::InvalidArgument("compiled artifact: truncated string (want ", len, " bytes, have ", + buf_.size() - pos_, ")"); + } + out->assign(buf_.data() + pos_, len); + pos_ += len; + return Status::OK(); + } + + Status ReadMagic(const std::array& expected, const char* label) { + if (pos_ + 4 > buf_.size()) { + return Status::InvalidArgument("compiled artifact: unexpected EOF reading ", label, " magic"); + } + for (int i = 0; i < 4; ++i) { + if (buf_[pos_ + i] != expected[i]) { + return Status::InvalidArgument("compiled artifact: wrong ", label, + " magic (not a JitFusion compiled artifact?)"); + } + } + pos_ += 4; + return Status::OK(); + } + + Status ReadBytesView(std::size_t n, std::string_view* out) { + if (pos_ + n > buf_.size()) { + return Status::InvalidArgument("compiled artifact: truncated blob (want ", n, " bytes, have ", buf_.size() - pos_, + ")"); + } + *out = std::string_view(buf_.data() + pos_, n); + pos_ += n; + return Status::OK(); + } + + Status ReadBytesCopy(std::size_t n, std::string* out) { + std::string_view v; + JF_RETURN_NOT_OK(ReadBytesView(n, &v)); + out->assign(v.data(), v.size()); + return Status::OK(); + } + + [[nodiscard]] std::size_t remaining() const { return buf_.size() - pos_; } + + private: + std::string_view buf_; + std::size_t pos_{}; +}; + +// Pin the numeric values of ArtifactFPMathMode / ArtifactMode to the +// on-wire encoding. If someone later reorders these enums, the +// static_asserts catch it at compile time instead of at Load time on +// a user's machine. +static_assert(static_cast(ArtifactFPMathMode::kStrict) == 0, "FPMathMode::kStrict must serialize as 0"); +static_assert(static_cast(ArtifactFPMathMode::kFast) == 1, "FPMathMode::kFast must serialize as 1"); +static_assert(static_cast(ArtifactMode::kSingle) == 0, "ArtifactMode::kSingle must serialize as 0"); +static_assert(static_cast(ArtifactMode::kBatch) == 1, "ArtifactMode::kBatch must serialize as 1"); + +} // namespace + +Status SerializeArtifact(const ArtifactHeader& header, std::string_view object_bytes, std::string* out) { + if (out == nullptr) { + return Status::InvalidArgument("SerializeArtifact: out must not be null"); + } + if (header.per_entry_ret_types.empty()) { + return Status::InvalidArgument("[internal] SerializeArtifact: header has 0 entries"); + } + if (header.mode == ArtifactMode::kSingle && header.per_entry_ret_types.size() != 1) { + return Status::InvalidArgument("[internal] SerializeArtifact: single-mode artifact must have exactly 1 entry, got ", + header.per_entry_ret_types.size()); + } + + // Pre-size. The object bytes dominate; a small over-reserve amortizes + // the header appends. We undersize by a few bytes rather than + // over-reserving — std::string growth is exponential anyway. + out->reserve(out->size() + 128 + object_bytes.size()); + + AppendBytes(*out, kArtifactMagic.data(), kArtifactMagic.size()); + AppendU32LE(*out, kArtifactFormatVersion); + AppendLenPrefixedStr(*out, header.llvm_version); + AppendLenPrefixedStr(*out, header.target_triple); + AppendLenPrefixedStr(*out, header.cpu_name); + AppendU8(*out, static_cast(header.mode)); + AppendU8(*out, static_cast(header.fp_math_mode)); + AppendU8(*out, static_cast(header.top_ret_type)); + + const auto num_entries = static_cast(header.per_entry_ret_types.size()); + AppendU32LE(*out, num_entries); + for (std::uint32_t i = 0; i < num_entries; ++i) { + AppendU8(*out, static_cast(header.per_entry_ret_types[i])); + } + + AppendU64LE(*out, static_cast(object_bytes.size())); + AppendBytes(*out, object_bytes.data(), object_bytes.size()); + + const auto ext_count = static_cast(header.extensions.size()); + AppendU32LE(*out, ext_count); + for (const auto& ext : header.extensions) { + AppendU32LE(*out, ext.tag); + AppendU32LE(*out, static_cast(ext.payload.size())); + AppendBytes(*out, ext.payload.data(), ext.payload.size()); + } + + AppendBytes(*out, kArtifactFooterMagic.data(), kArtifactFooterMagic.size()); + return Status::OK(); +} + +Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, std::string_view* out_object_bytes) { + if (out_header == nullptr || out_object_bytes == nullptr) { + return Status::InvalidArgument("DeserializeArtifact: output pointers must not be null"); + } + + ArtifactReader r(blob); + JF_RETURN_NOT_OK(r.ReadMagic(kArtifactMagic, "header")); + + std::uint32_t format_ver = 0; + JF_RETURN_NOT_OK(r.ReadU32LE(&format_ver)); + if (format_ver != kArtifactFormatVersion) { + // Strict equality, matching the industry norm for JIT artifact + // caches (ccache, rustc incremental, V8 codecache, Python .pyc). + // Forward-compat for purely additive changes lives in the + // extension area; anything else warrants a version bump. + return Status::InvalidArgument("compiled artifact: format version ", format_ver, + " not supported (this build expects ", kArtifactFormatVersion, + "). The artifact was produced by an incompatible jitfusion version."); + } + + JF_RETURN_NOT_OK(r.ReadLenPrefixedStr(&out_header->llvm_version)); + JF_RETURN_NOT_OK(r.ReadLenPrefixedStr(&out_header->target_triple)); + JF_RETURN_NOT_OK(r.ReadLenPrefixedStr(&out_header->cpu_name)); + + std::uint8_t mode_byte = 0; + JF_RETURN_NOT_OK(r.ReadU8(&mode_byte)); + if (mode_byte != static_cast(ArtifactMode::kSingle) && + mode_byte != static_cast(ArtifactMode::kBatch)) { + return Status::InvalidArgument("compiled artifact: unknown mode byte ", static_cast(mode_byte)); + } + out_header->mode = static_cast(mode_byte); + + std::uint8_t fp_byte = 0; + JF_RETURN_NOT_OK(r.ReadU8(&fp_byte)); + if (fp_byte != static_cast(ArtifactFPMathMode::kStrict) && + fp_byte != static_cast(ArtifactFPMathMode::kFast)) { + return Status::InvalidArgument("compiled artifact: unknown fp_math_mode byte ", static_cast(fp_byte)); + } + out_header->fp_math_mode = static_cast(fp_byte); + + std::uint8_t top_ret_type_byte = 0; + JF_RETURN_NOT_OK(r.ReadU8(&top_ret_type_byte)); + out_header->top_ret_type = static_cast(top_ret_type_byte); + + std::uint32_t num_entries = 0; + JF_RETURN_NOT_OK(r.ReadU32LE(&num_entries)); + if (num_entries == 0) { + return Status::InvalidArgument("compiled artifact: num_entries is 0"); + } + if (out_header->mode == ArtifactMode::kSingle && num_entries != 1) { + return Status::InvalidArgument("compiled artifact: single-mode artifact with num_entries=", num_entries); + } + out_header->per_entry_ret_types.resize(num_entries); + for (std::uint32_t i = 0; i < num_entries; ++i) { + std::uint8_t rt_byte = 0; + JF_RETURN_NOT_OK(r.ReadU8(&rt_byte)); + out_header->per_entry_ret_types[i] = static_cast(rt_byte); + } + // Cross-check: the top-level ret_type duplicates per_entry[0] in + // single mode and exists purely as a defense-in-depth marker. + // A mismatch indicates a corrupted or hand-tampered blob. + if (out_header->mode == ArtifactMode::kSingle && out_header->top_ret_type != out_header->per_entry_ret_types[0]) { + return Status::InvalidArgument( + "compiled artifact: inconsistent ret_type (top=", static_cast(out_header->top_ret_type), + ", per-entry=", static_cast(out_header->per_entry_ret_types[0]), ")"); + } + + std::uint64_t obj_size = 0; + JF_RETURN_NOT_OK(r.ReadU64LE(&obj_size)); + JF_RETURN_NOT_OK(r.ReadBytesView(static_cast(obj_size), out_object_bytes)); + + std::uint32_t ext_count = 0; + JF_RETURN_NOT_OK(r.ReadU32LE(&ext_count)); + out_header->extensions.clear(); + out_header->extensions.reserve(ext_count); + for (std::uint32_t i = 0; i < ext_count; ++i) { + ArtifactExtension ext; + JF_RETURN_NOT_OK(r.ReadU32LE(&ext.tag)); + std::uint32_t plen = 0; + JF_RETURN_NOT_OK(r.ReadU32LE(&plen)); + JF_RETURN_NOT_OK(r.ReadBytesCopy(plen, &ext.payload)); + // We do NOT attempt to interpret `ext.tag`. Unknown tags are + // preserved verbatim in the returned header so that a caller + // forwarding the blob (without modification) can still round-trip + // it. This matches protobuf's "unknown fields preservation" idea, + // which is what makes forward compatibility actually work in + // practice rather than just in spec. + out_header->extensions.emplace_back(std::move(ext)); + } + + JF_RETURN_NOT_OK(r.ReadMagic(kArtifactFooterMagic, "footer")); + if (r.remaining() != 0) { + return Status::InvalidArgument("compiled artifact: ", r.remaining(), " trailing bytes after footer"); + } + return Status::OK(); +} + +} // namespace jitfusion diff --git a/src/compiled_artifact.h b/src/compiled_artifact.h new file mode 100644 index 0000000..1edf8be --- /dev/null +++ b/src/compiled_artifact.h @@ -0,0 +1,179 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 16:13:51 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 16:43:30 + */ +/* + * Compiled-artifact (JFCA) serialization format. + * + * This module owns everything byte-level about the format that + * ExecEngine::SaveCompiled / LoadCompiled round-trip through: magic + * numbers, version, layout of core fields, the extension area, and + * the Read/Write primitives used by both sides. + * + * Design goals: + * 1. Self-contained blob. A reader with only the bytes in hand must + * be able to reject a foreign file (header magic), reject a blob + * produced by an incompatible version (format_version), and + * reject a blob produced on a different target (llvm_version, + * target_triple, cpu_name) — all before attempting to load the + * embedded object file. + * 2. Relocatable object payload. The object file bytes are inert + * data; resolution of undefined external symbols (C functions + * registered in FunctionRegistry) happens entirely at + * LoadCompiled time. This mirrors how a normal linker resolves + * relocations when loading a .o file. + * 3. Forward-compatible extension area. New optional metadata can + * be attached via tagged records at the end of the artifact. + * Old readers silently skip tags they do not recognize. If a + * change is not backward-compatible at the bytes level (e.g. + * the object payload is compressed), that is NOT an extension: + * it must bump format_version instead. + * + * Explicitly out of scope: + * - "Required extensions" (older readers must bail). Any change + * important enough to demand that behavior is by definition + * core-incompatible — bump format_version. + * - "Minimum reader version". Same reasoning: format_version + * mismatch already handles this cleanly. + * - ExecEngine / LLVM JIT concerns. This file does NOT include + * LLVM headers; it is pure bytes-in / bytes-out so it compiles + * fast and can be unit-tested without spinning up a JIT. + * + * Layout (little-endian integers where applicable): + * magic[4] = 'J','F','C','A' + * format_version uint32 (kArtifactFormatVersion) + * llvm_version len-prefixed utf8 str (LLVM_VERSION_STRING at save time) + * target_triple len-prefixed utf8 str (sys::getProcessTriple()) + * cpu_name len-prefixed utf8 str (sys::getHostCPUName()) + * mode uint8 (0 = single, 1 = batch) + * fp_math_mode uint8 (FPMathMode enum value) + * top_ret_type uint8 (ValueType; meaningful in single mode, + * duplicates per_entry_ret_types[0]) + * num_entries uint32 (>= 1) + * per-entry repeated num_entries times: + * ret_type uint8 (ValueType) + * obj_size uint64 + * obj_bytes raw bytes (the relocatable .o) + * extension_count uint32 (0 in v1) + * per-extension repeated extension_count times: + * tag uint32 (ArtifactExtensionTag) + * payload_len uint32 + * payload raw bytes + * footer_magic[4] = 'J','F','C','E' + * + * Notable non-field: + * Entry symbol names are NOT stored in the blob. They follow a + * deterministic scheme tied to `format_version` — currently "entry" + * for single mode and "entry" + std::to_string(i) for batch entry i + * — known to both SaveCompiled (via the codegen that produced the + * object) and LoadCompiled (which hardcodes the lookup names). + * Changing the scheme is a format-breaking event: either gate the + * new scheme behind a bumped format_version, or introduce an + * extension-area record that supplies explicit symbol names. + */ +#pragma once + +#include +#include +#include +#include +#include "status.h" +#include "type.h" + +namespace jitfusion { + +// Kept in sync with the FPMathMode in include/exec_engine.h. We do +// NOT include exec_engine.h here because that file pulls in LLVM — +// which would defeat the "pure serde, fast to compile" goal of this +// TU. Duplicating a 2-value enum is a fine tradeoff. +// +// Callers at the ExecEngine boundary are responsible for converting +// between FPMathMode and ArtifactFPMathMode. A static_assert pair in +// compiled_artifact.cc pins the numeric values to match. +enum class ArtifactFPMathMode : std::uint8_t { + kStrict = 0, + kFast = 1, +}; + +enum class ArtifactMode : std::uint8_t { + kSingle = 0, + kBatch = 1, +}; + +// Extension tag registry. New optional metadata features allocate a +// new tag here and append to ArtifactHeader::extensions; readers that +// do not recognize a tag skip the record silently. +// +// Rules when adding a tag: +// 1. Assign the next unused integer; never reuse a retired tag — +// readers in the wild may still expect the old meaning. +// 2. Document payload layout next to the tag. +// 3. The feature must be purely additive / advisory. A change that +// an old reader MUST notice (e.g. object bytes got compressed) +// is not an extension; bump kArtifactFormatVersion instead. +enum class ArtifactExtensionTag : std::uint32_t { + // No tags defined in v1. + // kExampleMetadata = 1, // payload: +}; + +struct ArtifactExtension { + std::uint32_t tag; // raw tag; cast to ArtifactExtensionTag if known + std::string payload; // opaque bytes, length implicit +}; + +// Structured view of everything in a JFCA artifact except the +// object payload itself. The object payload is kept separate so +// that Deserialize can return a zero-copy std::string_view into +// the caller's buffer (object bytes can be MB-sized; avoiding a +// copy matters). +struct ArtifactHeader { + // === Core, always present === + std::string llvm_version; + std::string target_triple; + std::string cpu_name; + ArtifactMode mode{ArtifactMode::kSingle}; + ArtifactFPMathMode fp_math_mode{ArtifactFPMathMode::kFast}; + ValueType top_ret_type{ValueType::kUnknown}; + // Per-entry return types; size doubles as the "num_entries" field + // on the wire. Entry symbol names are intentionally NOT stored — + // see the "Notable non-field" comment in the file header. + std::vector per_entry_ret_types; + + // === Forward-compat extension area === + std::vector extensions; +}; + +// Current format version written by SerializeArtifact. Bump on any +// change that breaks byte-level compatibility with existing readers. +// Purely additive changes via the extension area do NOT require a +// version bump. +constexpr std::uint32_t kArtifactFormatVersion = 1; + +// Serialize `header` + `object_bytes` into a self-contained JFCA +// blob. Appends to `*out` (does not clear), matching std::string's +// usual output-parameter convention and letting callers pre-reserve. +// +// The only failure mode today is a programming error (e.g. empty +// per_entry_ret_types, or single-mode with != 1 entry); runtime +// inputs cannot otherwise cause failure. +Status SerializeArtifact(const ArtifactHeader& header, std::string_view object_bytes, std::string* out); + +// Parse a JFCA blob. On success `*out_header` receives the header +// fields (including unknown extensions copied verbatim), and +// `*out_object_bytes` is a view into `blob` pointing at the object +// payload — so `blob` must outlive downstream use of the view. +// +// Returns Status::InvalidArgument with a human-readable message on +// any kind of rejection: wrong magic, unsupported format_version, +// truncation, trailing bytes, etc. The message is prefixed with +// "compiled artifact: " so it is easy to grep out in logs. +// +// Environment-compatibility checks (matching LLVM version / target +// triple / CPU name against the current process) are NOT performed +// here — those are policy decisions that belong at the ExecEngine +// level. Deserialize only guarantees the bytes parsed cleanly. +Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, std::string_view* out_object_bytes); + +} // namespace jitfusion diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 3e48962..673c3a1 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -2,18 +2,21 @@ * @Author: victorika * @Date: 2025-01-15 10:59:33 * @Last Modified by: victorika - * @Last Modified time: 2026-03-31 14:51:40 + * @Last Modified time: 2026-05-07 16:41:15 */ #include "exec_engine.h" #include #include #include #include "codegen/codegen.h" +#include "compiled_artifact.h" #include "exec_node.h" #include "function/function_init.h" #include "function_registry.h" #include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/Config/llvm-config.h" #include "llvm/ExecutionEngine/ExecutionEngine.h" +#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/LegacyPassManager.h" #include "llvm/IR/Value.h" @@ -23,6 +26,7 @@ #include "llvm/Support/Casting.h" #include "llvm/Support/CodeGen.h" #include "llvm/Support/DynamicLibrary.h" +#include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/TargetSelect.h" #include "llvm/Support/raw_ostream.h" #include "llvm/Target/TargetMachine.h" @@ -255,6 +259,7 @@ void ExecEngine::ResetCompiledState() { batch_entry_func_ptrs_.clear(); batch_ret_types_.clear(); ir_code_.clear(); + compiled_object_bytes_.clear(); } Status ExecEngine::Compile(const std::unique_ptr& exec_node, @@ -486,6 +491,9 @@ Status ExecEngine::BatchCompile(const std::vector>& ex func_ptr += func_offset->getValue(); batch_entry_func_ptrs_[i] = func_ptr; } + // Symbol names are deterministic ("entry" / "entryN") and re-derived + // inline by LoadCompiled / SaveCompiled; no need to stash func_names + // beyond this scope. return Status::OK(); } @@ -638,6 +646,16 @@ Status ExecEngine::CreateJitAndOptimize(const std::unique_ptr& return Status::RuntimeError("Failed to create DynamicLibrarySearchGenerator: ", llvm::toString(dlsg.takeError())); } jd.addGenerator(std::move(*dlsg)); + if (option_.enable_save_compiled) { + jit_->getObjTransformLayer().setTransform( + [this](std::unique_ptr obj_buf) -> llvm::Expected> { + if (obj_buf) { + llvm::StringRef data = obj_buf->getBuffer(); + compiled_object_bytes_.assign(data.data(), data.size()); + } + return obj_buf; + }); + } // optimize jit_->getIRTransformLayer().setTransform( [&, this](llvm::orc::ThreadSafeModule tsm, const llvm::orc::MaterializationResponsibility& /*r*/) { @@ -679,4 +697,129 @@ Status ExecEngine::CreateJitAndOptimize(const std::unique_ptr& return Status::OK(); } +Status ExecEngine::SaveCompiled(std::string* out) const { + if (out == nullptr) { + return Status::InvalidArgument("SaveCompiled: out must not be null"); + } + const bool nothing_compiled = (entry_func_ptr_ == nullptr) && batch_entry_func_ptrs_.empty(); + if (nothing_compiled) { + return Status::RuntimeError("SaveCompiled: nothing compiled yet. Call Compile() or BatchCompile() first."); + } + if (compiled_object_bytes_.empty()) { + return Status::RuntimeError( + "SaveCompiled: no object bytes captured. Set " + "ExecEngineOption::enable_save_compiled=true BEFORE calling Compile() / " + "BatchCompile(), then re-compile. (Artifacts loaded via LoadCompiled also " + "cannot be re-saved — the loaded bytes are intentionally not retained.)"); + } + + const bool is_batch = !batch_entry_func_ptrs_.empty(); + ArtifactHeader header; + header.llvm_version = LLVM_VERSION_STRING; + header.target_triple = llvm::sys::getProcessTriple(); + header.cpu_name = llvm::sys::getHostCPUName().str(); + header.mode = is_batch ? ArtifactMode::kBatch : ArtifactMode::kSingle; + header.fp_math_mode = + (option_.fp_math_mode == FPMathMode::kFast) ? ArtifactFPMathMode::kFast : ArtifactFPMathMode::kStrict; + header.top_ret_type = is_batch ? batch_ret_types_[0] : ret_type_; + + const size_t n = is_batch ? batch_entry_func_ptrs_.size() : 1U; + header.per_entry_ret_types.resize(n); + for (size_t i = 0; i < n; ++i) { + header.per_entry_ret_types[i] = is_batch ? batch_ret_types_[i] : ret_type_; + } + return SerializeArtifact(header, compiled_object_bytes_, out); +} + +Status ExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry) { + ArtifactHeader header; + std::string_view obj_view; + JF_RETURN_NOT_OK(DeserializeArtifact(bytes, &header, &obj_view)); + + if (header.llvm_version != LLVM_VERSION_STRING) { + return Status::InvalidArgument( + "compiled artifact: LLVM version mismatch (artifact=", header.llvm_version, ", runtime=", LLVM_VERSION_STRING, + "). LLVM does not guarantee object-file compatibility across versions; regenerate the artifact."); + } + { + const std::string current_triple = llvm::sys::getProcessTriple(); + if (header.target_triple != current_triple) { + return Status::InvalidArgument("compiled artifact: target triple mismatch (artifact=", header.target_triple, + ", runtime=", current_triple, ")"); + } + } + { + const std::string current_cpu = llvm::sys::getHostCPUName().str(); + if (header.cpu_name != current_cpu) { + return Status::InvalidArgument("compiled artifact: host CPU mismatch (artifact=", header.cpu_name, + ", runtime=", current_cpu, "). Regenerate the artifact on this host."); + } + } + + const bool is_batch = (header.mode == ArtifactMode::kBatch); + option_.fp_math_mode = (header.fp_math_mode == ArtifactFPMathMode::kFast) ? FPMathMode::kFast : FPMathMode::kStrict; + + ResetCompiledState(); + + static auto machine = LLVMInit(); + const auto fp_mode = option_.fp_math_mode; + auto jit_or_err = + llvm::orc::LLJITBuilder() + .setCompileFunctionCreator([fp_mode](llvm::orc::JITTargetMachineBuilder jtmb) + -> llvm::Expected> { + jtmb.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive); + if (fp_mode == FPMathMode::kFast) { + jtmb.getOptions().AllowFPOpFusion = llvm::FPOpFusion::Fast; + jtmb.getOptions().UnsafeFPMath = true; + } + return std::make_unique(std::move(jtmb)); + }) + .create(); + if (!jit_or_err) { + return Status::RuntimeError("LoadCompiled: failed to create LLJIT: ", llvm::toString(jit_or_err.takeError())); + } + jit_ = std::move(*jit_or_err); + + auto dlsg = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(jit_->getDataLayout().getGlobalPrefix()); + if (!dlsg) { + return Status::RuntimeError("LoadCompiled: failed to create DynamicLibrarySearchGenerator: ", + llvm::toString(dlsg.takeError())); + } + jit_->getMainJITDylib().addGenerator(std::move(*dlsg)); + auto obj_buf = + llvm::MemoryBuffer::getMemBufferCopy(llvm::StringRef(obj_view.data(), obj_view.size()), "jitfusion.loaded.o"); + if (auto err = jit_->addObjectFile(std::move(obj_buf))) { + return Status::RuntimeError("LoadCompiled: addObjectFile failed: ", llvm::toString(std::move(err))); + } + JF_RETURN_NOT_OK(func_registry->MappingToJIT(jit_.get())); + const size_t num_entries = header.per_entry_ret_types.size(); + if (is_batch) { + batch_ret_types_ = std::move(header.per_entry_ret_types); + batch_entry_func_ptrs_.resize(num_entries); + for (size_t i = 0; i < num_entries; ++i) { + const std::string sym = kEntryFunctionName + std::to_string(i); + auto off = jit_->lookup(sym); + if (!off) { + return Status::RuntimeError("LoadCompiled: entry symbol '", sym, + "' not found: ", llvm::toString(off.takeError()), + ". The FunctionRegistry is probably missing a function the artifact depends on."); + } + char* fp = nullptr; + fp += off->getValue(); + batch_entry_func_ptrs_[i] = fp; + } + } else { + ret_type_ = header.per_entry_ret_types[0]; + auto off = jit_->lookup(kEntryFunctionName); + if (!off) { + return Status::RuntimeError("LoadCompiled: entry symbol '", kEntryFunctionName, + "' not found: ", llvm::toString(off.takeError()), + ". The FunctionRegistry is probably missing a function the artifact depends on."); + } + entry_func_ptr_ = nullptr; + entry_func_ptr_ += off->getValue(); + } + return Status::OK(); +} + } // namespace jitfusion \ No newline at end of file diff --git a/test/save_load_test.cc b/test/save_load_test.cc new file mode 100644 index 0000000..d73d998 --- /dev/null +++ b/test/save_load_test.cc @@ -0,0 +1,358 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 16:13:43 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 16:13:43 + */ +/* + * End-to-end tests for ExecEngine::SaveCompiled / LoadCompiled. + * + * Covers the intended round-trip contract: + * 1. Simple scalar expression. + * 2. Expression that uses a ReadOnlyCFunc — Load must reuse the freshly + * supplied registry addresses, not any captured-at-save addresses. + * 3. Expression with constant list / string payloads — exercises the + * relocatable-constant globals path end-to-end (SaveCompiled captures + * the relocatable .o, LoadCompiled links it in a fresh JIT). + * 4. BatchCompile round-trip with multiple entry symbols / ret types. + * 5. Negative paths: bad magic, truncated blob, LLVM version mismatch, + * missing function on Load side, SaveCompiled after LoadCompiled. + */ +#include +#include +#include +#include +#include "exec_engine.h" +#include "exec_node.h" +#include "function_registry.h" +#include "gtest/gtest.h" +#include "status.h" +#include "type.h" + +using namespace jitfusion; + +namespace { + +int32_t LoadI32(void* data, int32_t i) { return reinterpret_cast(data)[i]; } + +std::unique_ptr MakeRegistry() { + std::unique_ptr reg; + FunctionRegistryFactory::CreateFunctionRegistry(®); + return reg; +} + +std::unique_ptr MakeRegistryWithLoadI32() { + auto reg = MakeRegistry(); + FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); + EXPECT_TRUE(reg->RegisterReadOnlyCFunc(sign, reinterpret_cast(LoadI32)).ok()); + return reg; +} + +// Build an ExecEngine configured so that SaveCompiled is usable after +// Compile. Using this everywhere makes the opt-in nature of save +// capture explicit in every test, and catches regressions where a new +// code path forgets to set the option. +ExecEngineOption SaveCapableOption() { + ExecEngineOption opt; + opt.enable_save_compiled = true; + return opt; +} + +} // namespace + +// --------------------------------------------------------------------------- +// Scenario 1: trivial scalar constant — no functions, no payloads. +// Purpose: confirm the wire format is well-formed for the smallest case +// and that LoadCompiled produces an engine that behaves identically. +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, ScalarConstantRoundTrip) { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(static_cast(42))); + + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()) << "SaveCompiled failed"; + EXPECT_GT(blob.size(), 32u) << "Artifact should be at least header + object bytes"; + + // Load into a completely separate engine + registry to prove no hidden + // state leaks from the source engine. + auto reg2 = MakeRegistry(); + ExecEngine dst; + ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()) << "LoadCompiled failed"; + + RetType r; + ASSERT_TRUE(dst.Execute(nullptr, &r).ok()); + EXPECT_EQ(std::get(r), 42); +} + +// --------------------------------------------------------------------------- +// Scenario 2: expression that calls a ReadOnlyCFunc. +// Purpose: the saved .o contains an undefined reference to "load(...)"; +// LoadCompiled must resolve it from the Load-side registry, not from any +// address encoded at Save time. We demonstrate this by giving the Load +// side a freshly-constructed registry (different heap address than the +// Save side, though pointing to the same C function). +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, ReadOnlyCFuncResolvesOnLoadSideRegistry) { + auto reg_save = MakeRegistryWithLoadI32(); + + auto arg = std::unique_ptr(new EntryArgumentNode); + auto idx = std::unique_ptr(new ConstantValueNode(static_cast(2))); + std::vector> args; + args.emplace_back(std::move(arg)); + args.emplace_back(std::move(idx)); + auto call = std::unique_ptr(new FunctionNode("load", std::move(args))); + + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(call, reg_save).ok()); + + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + auto reg_load = MakeRegistryWithLoadI32(); // distinct registry instance + ExecEngine dst; + ASSERT_TRUE(dst.LoadCompiled(blob, reg_load).ok()); + + std::vector input = {10, 20, 30, 40}; + RetType r; + ASSERT_TRUE(dst.Execute(input.data(), &r).ok()); + EXPECT_EQ(std::get(r), 30); +} + +// --------------------------------------------------------------------------- +// Scenario 3: constant list + string payloads. +// Purpose: this is the exact path that required the "relocatable globals" +// refactor. If the codegen ever regresses to inttoptr-based payloads, the +// .o file would embed process-local addresses and LoadCompiled would +// either crash or produce garbage. Running SaveCompiled + LoadCompiled in +// the same process still exercises the serialization/deserialization +// logic, and — since the globals are baked into the .o — proves they +// travel with the artifact rather than being resolved from live memory. +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, ConstantStringAndListRoundTrip) { + // String literal. + { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(std::string("jitfusion"))); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + ExecEngine dst; + auto reg2 = MakeRegistry(); + ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()); + RetType r; + ASSERT_TRUE(dst.Execute(nullptr, &r).ok()); + EXPECT_EQ(std::get(r), "jitfusion"); + } + // Numeric list (exercises EmitTypedArrayGlobal). + { + auto reg = MakeRegistry(); + std::vector data = {7, 8, 9, 10, 11, 12}; + auto node = std::unique_ptr(new ConstantListValueNode(data)); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + ExecEngine dst; + auto reg2 = MakeRegistry(); + ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()); + RetType r; + ASSERT_TRUE(dst.Execute(nullptr, &r).ok()); + EXPECT_EQ(std::get>(r), data); + } + // String list (exercises the two-level global path). + { + auto reg = MakeRegistry(); + std::vector data = {"alpha", "beta", "", "gamma"}; + auto node = std::unique_ptr(new ConstantListValueNode(data)); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + ExecEngine dst; + auto reg2 = MakeRegistry(); + ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()); + RetType r; + ASSERT_TRUE(dst.Execute(nullptr, &r).ok()); + EXPECT_EQ(std::get>(r), data); + } +} + +// --------------------------------------------------------------------------- +// Scenario 4: BatchCompile round-trip. +// Purpose: exercises the multi-symbol + per-entry ret_type path through +// the format. We deliberately mix return types so a missing per-entry +// ret_type would surface as a type-mismatched Execute. +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, BatchCompileRoundTrip) { + auto reg = MakeRegistry(); + std::vector> nodes; + nodes.emplace_back(new ConstantValueNode(static_cast(111))); + nodes.emplace_back(new ConstantValueNode(static_cast(2.5))); + nodes.emplace_back(new ConstantValueNode(std::string("batched"))); + + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.BatchCompile(nodes, reg).ok()); + ASSERT_EQ(src.GetBatchFunctionCount(), 3u); + + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + ExecEngine dst; + auto reg2 = MakeRegistry(); + ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()); + ASSERT_EQ(dst.GetBatchFunctionCount(), 3u); + EXPECT_EQ(dst.GetBatchFunctionReturnType(0), ValueType::kI32); + EXPECT_EQ(dst.GetBatchFunctionReturnType(1), ValueType::kF64); + EXPECT_EQ(dst.GetBatchFunctionReturnType(2), ValueType::kString); + + RetType r; + ASSERT_TRUE(dst.ExecuteAt(0, nullptr, &r).ok()); + EXPECT_EQ(std::get(r), 111); + ASSERT_TRUE(dst.ExecuteAt(1, nullptr, &r).ok()); + EXPECT_DOUBLE_EQ(std::get(r), 2.5); + ASSERT_TRUE(dst.ExecuteAt(2, nullptr, &r).ok()); + EXPECT_EQ(std::get(r), "batched"); +} + +// --------------------------------------------------------------------------- +// Scenario 5a: SaveCompiled before Compile is an error (nothing to save). +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, SaveBeforeCompileFails) { + ExecEngine engine; + std::string blob; + auto st = engine.SaveCompiled(&blob); + EXPECT_FALSE(st.ok()) << st.ToString(); +} + +// --------------------------------------------------------------------------- +// Scenario 5a': Compile ran, but enable_save_compiled was left at its +// default (false) — SaveCompiled must fail with a message that points at +// the opt-in, not just "nothing to save". We verify the message mentions +// the option name so users can fix their setup without reading source. +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, SaveWithoutOptInFails) { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(static_cast(1))); + ExecEngine engine; // default option: enable_save_compiled=false + ASSERT_TRUE(engine.Compile(node, reg).ok()); + + std::string blob; + auto st = engine.SaveCompiled(&blob); + ASSERT_FALSE(st.ok()); + // Spot-check that the error message is actionable. We don't pin the + // exact wording, just the identifier of the option the user needs to + // flip — that's what makes the message useful. + EXPECT_NE(st.ToString().find("enable_save_compiled"), std::string::npos) + << "Error should reference enable_save_compiled. Actual: " << st.ToString(); +} + +// --------------------------------------------------------------------------- +// Scenario 5b: Re-save after Load is rejected (we deliberately do not +// keep the loaded bytes around — documented in the header). +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, ResaveAfterLoadFails) { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(static_cast(1))); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + // Note: dst intentionally does NOT enable_save_compiled — LoadCompiled + // shouldn't care about that option, and we want to verify the re-save + // block still kicks in. Flipping the option on the load side would not + // change the outcome because LoadCompiled deliberately leaves + // compiled_object_bytes_ empty. + ExecEngine dst; + ASSERT_TRUE(dst.LoadCompiled(blob, reg).ok()); + + std::string blob2; + auto st = dst.SaveCompiled(&blob2); + EXPECT_FALSE(st.ok()) << "Re-save after load should be rejected; got: " << st.ToString(); +} + +// --------------------------------------------------------------------------- +// Scenario 5c: corrupted / foreign input is rejected cleanly +// (no crash, meaningful error message). +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, LoadRejectsGarbage) { + auto reg = MakeRegistry(); + ExecEngine dst; + + // Completely empty + EXPECT_FALSE(dst.LoadCompiled("", reg).ok()); + // Too short to contain even the magic + EXPECT_FALSE(dst.LoadCompiled("JF", reg).ok()); + // Wrong magic + EXPECT_FALSE(dst.LoadCompiled("ZZZZZZZZZZZZZZZZ", reg).ok()); +} + +TEST(SaveLoadTest, LoadRejectsTruncatedBlob) { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(static_cast(1))); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + // Drop the footer and some of the object bytes. The parser should + // surface a truncation error on the footer read, not crash. + std::string truncated = blob.substr(0, blob.size() - 8); + ExecEngine dst; + auto st = dst.LoadCompiled(truncated, reg); + EXPECT_FALSE(st.ok()) << "Truncated blob should be rejected"; +} + +TEST(SaveLoadTest, LoadRejectsTamperedLLVMVersion) { + auto reg = MakeRegistry(); + auto node = std::unique_ptr(new ConstantValueNode(static_cast(1))); + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(node, reg).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + // The llvm version string lives right after magic(4) + format_version(4). + // Its length prefix is at offset 8. Mutate one byte of the payload so + // the stored version no longer matches the runtime's. + ASSERT_GT(blob.size(), 20u); + // offset 8..11: u32 length. offset 12: first byte of llvm version string. + // Flip first character of the version string; will cause strict compare + // to fail. + blob[12] = (blob[12] == 'X' ? 'Y' : 'X'); + ExecEngine dst; + auto st = dst.LoadCompiled(blob, reg); + EXPECT_FALSE(st.ok()) << "Tampered LLVM version must be rejected; got: " << st.ToString(); +} + +// --------------------------------------------------------------------------- +// Scenario 5d: Load-side registry missing the function referenced by the +// artifact. Must fail at LoadCompiled (symbol lookup stage), not silently +// succeed and then crash on Execute. +// --------------------------------------------------------------------------- +TEST(SaveLoadTest, LoadFailsWhenRegistryMissesFunction) { + auto reg_save = MakeRegistryWithLoadI32(); + auto arg = std::unique_ptr(new EntryArgumentNode); + auto idx = std::unique_ptr(new ConstantValueNode(static_cast(0))); + std::vector> args; + args.emplace_back(std::move(arg)); + args.emplace_back(std::move(idx)); + auto call = std::unique_ptr(new FunctionNode("load", std::move(args))); + + ExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(call, reg_save).ok()); + std::string blob; + ASSERT_TRUE(src.SaveCompiled(&blob).ok()); + + // Load side supplies a bare registry with no "load" function. + auto reg_load = MakeRegistry(); + ExecEngine dst; + auto st = dst.LoadCompiled(blob, reg_load); + EXPECT_FALSE(st.ok()) << "Load should fail fast if a required function is missing; got: " << st.ToString(); +} From 55246acb121cb47fd5bf91795875fee176fe9b96 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 16:50:34 +0800 Subject: [PATCH 19/41] format --- src/compiled_artifact.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/compiled_artifact.h b/src/compiled_artifact.h index 1edf8be..475a74f 100644 --- a/src/compiled_artifact.h +++ b/src/compiled_artifact.h @@ -1,6 +1,6 @@ /* - * @Author: victorika - * @Date: 2026-05-07 16:13:51 + * @Author: victorika + * @Date: 2026-05-07 16:13:51 * @Last Modified by: victorika * @Last Modified time: 2026-05-07 16:43:30 */ @@ -119,8 +119,8 @@ enum class ArtifactExtensionTag : std::uint32_t { }; struct ArtifactExtension { - std::uint32_t tag; // raw tag; cast to ArtifactExtensionTag if known - std::string payload; // opaque bytes, length implicit + std::uint32_t tag; // raw tag; cast to ArtifactExtensionTag if known + std::string payload; // opaque bytes, length implicit }; // Structured view of everything in a JFCA artifact except the From 45bac1b4768b1203aeb96e75f7df9ab5f29f638f Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 16:51:05 +0800 Subject: [PATCH 20/41] format code --- test/save_load_test.cc | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/test/save_load_test.cc b/test/save_load_test.cc index d73d998..2994e31 100644 --- a/test/save_load_test.cc +++ b/test/save_load_test.cc @@ -1,8 +1,8 @@ /* - * @Author: victorika - * @Date: 2026-05-07 16:13:43 - * @Last Modified by: victorika - * @Last Modified time: 2026-05-07 16:13:43 + * @Author: victorika + * @Date: 2026-05-07 16:13:43 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 16:13:43 */ /* * End-to-end tests for ExecEngine::SaveCompiled / LoadCompiled. From eba81557fde7a06ae5425f96c7c83fa32e4ca705 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 16:51:55 +0800 Subject: [PATCH 21/41] remove useless code --- src/exec_engine.cc | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 673c3a1..13e7a12 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -491,10 +491,6 @@ Status ExecEngine::BatchCompile(const std::vector>& ex func_ptr += func_offset->getValue(); batch_entry_func_ptrs_[i] = func_ptr; } - // Symbol names are deterministic ("entry" / "entryN") and re-derived - // inline by LoadCompiled / SaveCompiled; no need to stash func_names - // beyond this scope. - return Status::OK(); } From f598d5687529cae06235c9f4a004f5362d52e6ab Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 17:19:02 +0800 Subject: [PATCH 22/41] fix readme --- .gitignore | 2 ++ README.md | 22 ++++++++++++++-------- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/.gitignore b/.gitignore index 544a8de..ef566c7 100644 --- a/.gitignore +++ b/.gitignore @@ -5,4 +5,6 @@ compile_commands.json MODULE.bazel.lock /build +/cmake-build* +/out .bazelrc \ No newline at end of file diff --git a/README.md b/README.md index b7ba02e..14c6973 100644 --- a/README.md +++ b/README.md @@ -16,9 +16,15 @@ llvm-config --version ``` ## CMake Build + +> Note: the repository root contains a Bazel `BUILD` file, so on +> case-insensitive filesystems (default APFS on macOS, NTFS on Windows) +> a build tree literally named `build` collides with it. Use a +> differently-cased directory such as `cmake-build` (used below) or `out`. + ```bash -cmake -B build -cmake --build build -j +cmake -B cmake-build +cmake --build cmake-build -j ``` The build defaults to `Release` (`-O3 -DNDEBUG`) when `CMAKE_BUILD_TYPE` is @@ -39,9 +45,9 @@ xsimd acceleration is optional. The `HAS_XSIMD` option accepts three values: Example: ```bash -cmake -B build -DHAS_XSIMD=ON # require xsimd -cmake -B build -DHAS_XSIMD=OFF # disable xsimd -cmake -B build # AUTO (default) +cmake -B cmake-build -DHAS_XSIMD=ON # require xsimd +cmake -B cmake-build -DHAS_XSIMD=OFF # disable xsimd +cmake -B cmake-build # AUTO (default) ``` ### Install @@ -51,9 +57,9 @@ headers and a CMake package config so that downstream projects can consume jitfusion via `find_package`. ```bash -cmake -B build -cmake --build build -j -cmake --install build --prefix /path/to/install +cmake -B cmake-build +cmake --build cmake-build -j +cmake --install cmake-build --prefix /path/to/install ``` Layout of the install tree: From 23db0b82eedd832f9fb1c489394c458a6198000f Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Thu, 7 May 2026 17:27:21 +0800 Subject: [PATCH 23/41] add sign --- benchmark/bench_common.h | 6 ++++++ benchmark/bench_compile.cc | 6 ++++++ benchmark/bench_execute_core.cc | 6 ++++++ benchmark/bench_list_agg.cc | 6 ++++++ benchmark/bench_list_basic.cc | 6 ++++++ benchmark/bench_list_binary.cc | 6 ++++++ benchmark/bench_list_compare.cc | 6 ++++++ benchmark/bench_list_indexing.cc | 6 ++++++ benchmark/bench_native_base.cc | 6 ++++++ test/empty_list_test.cc | 6 ++++++ test/list_aggregation_test.cc | 6 ++++++ test/list_arithmetic_test.cc | 6 ++++++ test/list_basic_test.cc | 6 ++++++ test/list_bitwise_test.cc | 6 ++++++ test/list_cast_test.cc | 6 ++++++ test/list_comparison_test.cc | 6 ++++++ test/list_conditional_test.cc | 6 ++++++ test/list_math_test.cc | 6 ++++++ test/list_misc_test.cc | 6 ++++++ test/relocatable_const_test.cc | 6 ++++++ 20 files changed, 120 insertions(+) diff --git a/benchmark/bench_common.h b/benchmark/bench_common.h index 30a68e0..31aeb95 100644 --- a/benchmark/bench_common.h +++ b/benchmark/bench_common.h @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // Shared AST/registry helpers for JitFusion benchmark TUs. // // Splitting engine_benchmark.cc into per-category files (bench_compile.cc, diff --git a/benchmark/bench_compile.cc b/benchmark/bench_compile.cc index 9e332ff..51fd519 100644 --- a/benchmark/bench_compile.cc +++ b/benchmark/bench_compile.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // JitFusion engine benchmarks. // // Benchmark names, once merged, MUST NOT be renamed — the CI pipeline diff --git a/benchmark/bench_execute_core.cc b/benchmark/bench_execute_core.cc index 7e8769f..a99a3ce 100644 --- a/benchmark/bench_execute_core.cc +++ b/benchmark/bench_execute_core.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // B. Execute — core (non-list) execution benchmarks. See bench_compile.cc // for the split overview. BENCHMARK_MAIN lives in bench_compile.cc. diff --git a/benchmark/bench_list_agg.cc b/benchmark/bench_list_agg.cc index 8073fac..7afb117 100644 --- a/benchmark/bench_list_agg.cc +++ b/benchmark/bench_list_agg.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // C. List aggregation + C-group. See bench_compile.cc for the split overview. #include "benchmark/bench_common.h" diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc index c9d95f7..f408901 100644 --- a/benchmark/bench_list_basic.cc +++ b/benchmark/bench_list_basic.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // G. List basic (shape manipulation) + H. List element-wise unary. // See bench_compile.cc for the split overview. diff --git a/benchmark/bench_list_binary.cc b/benchmark/bench_list_binary.cc index 22cb915..e9977c9 100644 --- a/benchmark/bench_list_binary.cc +++ b/benchmark/bench_list_binary.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // I. List element-wise binary — two shapes (scalar broadcast + list-list zip). // See bench_compile.cc for the split overview. diff --git a/benchmark/bench_list_compare.cc b/benchmark/bench_list_compare.cc index e1c702d..80a7ef9 100644 --- a/benchmark/bench_list_compare.cc +++ b/benchmark/bench_list_compare.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // J. List comparison / bitmap kernels. See bench_compile.cc for the overview. #include "benchmark/bench_common.h" diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc index 651129d..ec14f15 100644 --- a/benchmark/bench_list_indexing.cc +++ b/benchmark/bench_list_indexing.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-06 12:48:50 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-06 12:48:50 + */ // K. List indexing kernels: lookup / compact / gather. // // Kernel overview: diff --git a/benchmark/bench_native_base.cc b/benchmark/bench_native_base.cc index d81e976..4853895 100644 --- a/benchmark/bench_native_base.cc +++ b/benchmark/bench_native_base.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-30 16:07:33 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-30 16:07:33 + */ // D. ExecContext arena reuse vs fresh. // E. Batch execute (ExecuteAll / ExecuteAt loop). // F. Hand-written native C++ baselines. diff --git a/test/empty_list_test.cc b/test/empty_list_test.cc index a94ca81..a244987 100644 --- a/test/empty_list_test.cc +++ b/test/empty_list_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-27 16:16:22 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-27 16:16:22 + */ #include #include #include diff --git a/test/list_aggregation_test.cc b/test/list_aggregation_test.cc index 0653cbc..11aeb77 100644 --- a/test/list_aggregation_test.cc +++ b/test/list_aggregation_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_arithmetic_test.cc b/test/list_arithmetic_test.cc index ef9b483..e917b81 100644 --- a/test/list_arithmetic_test.cc +++ b/test/list_arithmetic_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_basic_test.cc b/test/list_basic_test.cc index a63470b..483da1f 100644 --- a/test/list_basic_test.cc +++ b/test/list_basic_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_bitwise_test.cc b/test/list_bitwise_test.cc index 5a86a42..4320dd9 100644 --- a/test/list_bitwise_test.cc +++ b/test/list_bitwise_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_cast_test.cc b/test/list_cast_test.cc index 9708dac..5e0a5e9 100644 --- a/test/list_cast_test.cc +++ b/test/list_cast_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_comparison_test.cc b/test/list_comparison_test.cc index 47ef9b3..cd5d38d 100644 --- a/test/list_comparison_test.cc +++ b/test/list_comparison_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_conditional_test.cc b/test/list_conditional_test.cc index 78fe27f..2372539 100644 --- a/test/list_conditional_test.cc +++ b/test/list_conditional_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_math_test.cc b/test/list_math_test.cc index d712e2b..cbececb 100644 --- a/test/list_math_test.cc +++ b/test/list_math_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/list_misc_test.cc b/test/list_misc_test.cc index 5b4b3bc..a742d9a 100644 --- a/test/list_misc_test.cc +++ b/test/list_misc_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-04-16 11:22:31 + * @Last Modified by: victorika + * @Last Modified time: 2026-04-16 11:22:31 + */ #include #include #include diff --git a/test/relocatable_const_test.cc b/test/relocatable_const_test.cc index 5faa925..38e454a 100644 --- a/test/relocatable_const_test.cc +++ b/test/relocatable_const_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 14:30:30 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 14:30:30 + */ /* * Regression tests for the "relocatable constants" refactor. * From 36d5b1854589907f5040478bc8ff3c9f39256c11 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 10:41:09 +0800 Subject: [PATCH 24/41] disassembling Athena --- CMakeLists.txt | 6 +- README.md | 22 +- athena/README.md | 20 +- athena/athena.cc | 26 +- athena/athena.h | 112 ++-- athena/test/const_value_test.cc | 14 +- athena/test/control_flow_test.cc | 24 +- athena/test/cse_test.cc | 18 +- athena/test/diagnostic_test.cc | 59 ++- athena/test/exec_error_test.cc | 9 +- athena/test/function_test.cc | 54 +- athena/test/list_function_test.cc | 18 +- athena/test/logical_op_test.cc | 56 +- athena/test/operator_test.cc | 46 +- athena/test/pipeline_test.cc | 43 +- athena/test/ref_node_test.cc | 27 +- athena/test/string_function_test.cc | 16 +- athena/test/when_test.cc | 53 +- benchmark/bench_common.h | 14 +- benchmark/bench_compile.cc | 16 +- benchmark/bench_native_base.cc | 16 +- include/batch_exec_engine.h | 117 +++++ include/exec_engine.h | 233 ++------- include/exec_options.h | 133 +++++ src/batch_exec_engine.cc | 252 +++++++++ src/compiled_artifact.cc | 30 +- src/compiled_artifact.h | 35 +- src/exec_engine.cc | 785 +++------------------------- src/execute_dispatch.h | 189 +++++++ src/jit_core.cc | 372 +++++++++++++ src/jit_core.h | 98 ++++ test/exec_error_test.cc | 29 +- test/save_load_test.cc | 17 +- 33 files changed, 1687 insertions(+), 1272 deletions(-) create mode 100644 include/batch_exec_engine.h create mode 100644 include/exec_options.h create mode 100644 src/batch_exec_engine.cc create mode 100644 src/execute_dispatch.h create mode 100644 src/jit_core.cc create mode 100644 src/jit_core.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 94b6a32..f96a935 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -245,9 +245,9 @@ if(JITFUSION_INSTALL) FILES_MATCHING PATTERN "*.h") # athena public headers -> /include/athena/ - # Only the files referenced by athena/athena.h (directly or transitively) - # are part of the public surface; implementation headers like token.ll - # or the generated shell script are excluded. + # Only the files referenced by athena.h (directly or transitively) are + # part of the public surface; implementation headers like token.ll or + # the generated shell script are excluded. install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/athena/athena.h" "${CMAKE_CURRENT_SOURCE_DIR}/athena/ast_builder.h" diff --git a/README.md b/README.md index 14c6973..b72adf7 100644 --- a/README.md +++ b/README.md @@ -8,7 +8,7 @@ Environment * googletest * xsimd-13.2.0 (optional) -First, you need to have LLVM 19.1.7; other versions will not work. However, if you can only use other versions, you can modify the exec_engine.cc file to adapt it, and it shouldn't require too many changes. +First, you need to have LLVM 19.1.7; other versions will not work. However, if you can only use other versions, you can modify the `src/jit_core.cc` file (where the LLVM ORC integration lives) to adapt it, and it shouldn't require too many changes. You can use the following command to check your version. ```bash @@ -150,7 +150,7 @@ I considered how many types of nodes are needed to represent a function in the e -In jitfusion, there are the following data types: u8, u16, u32, u64, i8, i16, i32, i64, float, double, string, u8list, u16list, u32list, u64list, i8list, i16list, i32list, i64list, floatlist, doublelist, stringlist. The type u8 corresponds to uint8_t in C, and so on. The C structures corresponding to all types can be found in the include/type.h file. +In jitfusion, there are the following data types: u8, u16, u32, u64, i8, i16, i32, i64, f32, f64, string, u8list, u16list, u32list, u64list, i8list, i16list, i32list, i64list, f32list, f64list, stringlist. The type u8 corresponds to uint8_t in C, f32 corresponds to float, f64 corresponds to double, and so on. The C structures corresponding to all types can be found in the include/type.h file. For example, generally speaking, the process of an execution flow graph might look like this. @@ -202,16 +202,20 @@ The intermediate processes can all be converted into corresponding op nodes, fun ## Batch compilation -If you have many small expressions that all operate on the same inputs, you can compile them together into a single LLVM module with `BatchCompile`. All functions share the same JIT engine, so they use fewer memory pages and are slightly faster to initialize overall than compiling each expression in its own `ExecEngine`. +If you have many small expressions that all operate on the same inputs, you can compile them together into a single LLVM module with `BatchExecEngine`. All functions share the same JIT engine, so they use fewer memory pages and are slightly faster to initialize overall than compiling each expression in its own `ExecEngine`. + +`BatchExecEngine` is declared in `` and is a sibling of `ExecEngine` — use the plain `ExecEngine` for one expression, `BatchExecEngine` for N >= 1 expressions sharing one JIT. ```c++ +#include + std::vector> nodes; nodes.emplace_back(MakeExpr1()); nodes.emplace_back(MakeExpr2()); nodes.emplace_back(MakeExpr3()); -ExecEngine exec_engine; -auto st = exec_engine.BatchCompile(nodes, func_registry); +BatchExecEngine exec_engine; +auto st = exec_engine.Compile(nodes, func_registry); // Execute a single one by index: RetType r0, r1, r2; @@ -227,7 +231,7 @@ exec_engine.ExecuteAll(entry_args, &results); // use the overloads that take a `void*` result pointer instead. ``` -Each expression may have its own return type; use `GetBatchFunctionReturnType(index)` to introspect. +Each expression may have its own return type; use `GetReturnType(index)` to introspect, and `GetFunctionCount()` to query how many entries were compiled. # Optimize It is more recommended to use this interface. @@ -281,7 +285,7 @@ When you reuse the same `ExecContext` across multiple `Execute(ExecContext&, ... | Field | Default | Purpose | | --- | --- | --- | | `exec_ctx_arena_alloc_min_chunk_size` | `4096` | Minimum chunk size for the per-execution arena created when you call an `Execute*` overload that does **not** take an explicit `ExecContext`. Ignored for the `ExecContext&` overloads (the caller owns the arena). | -| `dump_ir` | `false` | When `true`, the fully optimized LLVM IR text is captured during `Compile` / `BatchCompile` and made available via `GetIRCode()`. Useful for debugging; avoid enabling in production because serializing a large Module to text is expensive. | +| `dump_ir` | `false` | When `true`, the fully optimized LLVM IR text is captured during `Compile` and made available via `GetIRCode()`. Useful for debugging; avoid enabling in production because serializing a large Module to text is expensive. | | `fp_math_mode` | `FPMathMode::kFast` | Floating-point semantics requested from the JIT backend. `kFast` enables FMA fusion and `-ffast-math`-style algebraic rewrites (1.3x - 2x faster on FP-heavy list kernels). Switch to `kStrict` if you need bit-for-bit IEEE-754 reproducibility (finance / risk / regression tests). | Example: @@ -297,8 +301,8 @@ ExecEngine exec_engine(opt); The library is designed around a "compile once, execute from many threads" pattern. -* `Compile()` / `BatchCompile()` are **not** thread-safe. Call them from exactly one thread and finish them before any `Execute*` call. -* After a successful compile, the `Execute*` / `ExecuteAt*` / `ExecuteAll*` overloads are safe to invoke concurrently from multiple threads on the same `ExecEngine` — as long as each thread supplies its own `ExecContext`. +* `Compile()` is **not** thread-safe. Call it from exactly one thread and finish it before any `Execute*` call. The same applies to `BatchExecEngine::Compile()`. +* After a successful compile, the `Execute*` / `ExecuteAt*` / `ExecuteAll*` overloads are safe to invoke concurrently from multiple threads on the same engine instance — as long as each thread supplies its own `ExecContext`. * A single `ExecContext` must **never** be shared across threads. * The `Execute*` overloads that do not take an explicit `ExecContext` internally construct a fresh one on every call. They remain thread-safe but pay per-call allocation cost; prefer the `ExecContext&` overloads on hot paths. diff --git a/athena/README.md b/athena/README.md index 2e5cbc0..2803b05 100644 --- a/athena/README.md +++ b/athena/README.md @@ -3,7 +3,18 @@ An execution engine utilizing DSL in combination with jitfusion. # How to use -When using it, you need to #include "athena.h" and depend on the athena target. +Athena ships two sibling classes, picked by the shape of your DSL code: + +* `AthenaExpression` — "one expression, one return value". + `#include "athena.h"`, construct `AthenaExpression athena;`, + call `athena.Compile(code, registry)` with a single `std::string`. +* `AthenaPipeline` — "multiple pipeline statements, writing through custom + store functions". + `#include "athena.h"`, construct `AthenaPipeline athena;`, + call `athena.Compile(codes, registry)` with a `std::vector`. + +Both classes live in `namespace athena`, are declared in the same header +`athena/athena.h`, and depend on the athena target. ## DSL Rule @@ -30,13 +41,18 @@ Note: Variables modified inside `when` branches must maintain the same type as t * 5.You can obtain the input parameter pointer through the entry_arg name, access the ExecContext via exec_ctx and obtain the output parameter pointer through the output name. ## Execute Funtion + +`AthenaExpression` — expression mode: ```c++ // Applicable to simple scenarios, the program will not actually use a custom store function to write data. Instead, // the result will be returned, similar to expression scenarios. Status Compile(const std::string& code, const std::unique_ptr& func_registry); Status Execute(void* entry_arguments, RetType* result); Status Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result); +``` +`AthenaPipeline` — pipeline mode: +```c++ // Applicable to complex scenarios where multiple pipelines are computed simultaneously. Each pipeline writes data // using a custom function, and results are not returned. This is similar to feature processing scenarios. Status Compile(const std::vector& code, const std::unique_ptr& func_registry); @@ -44,7 +60,7 @@ Note: Variables modified inside `when` branches must maintain the same type as t Status Execute(ExecContext& exec_ctx, void* entry_arguments, void* result); ``` -The first set of functions returns a value through the last statement and requires that no write operations occur during the process; otherwise, it results in undefined behavior. The second set of functions can accept multiple sets of code, where the statement requires the user to define a custom store function to write data. The function will perform merge and optimization processing on all the code. +`AthenaExpression` returns a value through the last statement and requires that no write operations occur during the process; otherwise, it results in undefined behavior. `AthenaPipeline` accepts multiple sets of code; each statement requires the user to define a custom store function to write data. The engine performs merge and optimization processing on all the code. The `Execute` overloads that accept an `ExecContext&` parameter allow you to reuse a pre-allocated ExecContext, avoiding repeated memory allocation overhead. This is useful for high-performance scenarios where the execution engine is called frequently. diff --git a/athena/athena.cc b/athena/athena.cc index 3a14f0f..f6878ef 100644 --- a/athena/athena.cc +++ b/athena/athena.cc @@ -2,10 +2,11 @@ * @Author: victorika * @Date: 2025-04-09 15:44:26 * @Last Modified by: victorika - * @Last Modified time: 2026-04-07 15:23:43 + * @Last Modified time: 2026-05-08 10:00:00 */ #include "athena.h" #include "ast_builder.h" +#include "batch_exec_engine.h" #include "exec_engine.h" #include "function_registry.h" #include "pipeline_grouper.h" @@ -13,20 +14,15 @@ namespace athena { -Status Athena::Compile(const std::string& code, const std::unique_ptr& func_registry) { +Status AthenaExpression::Compile(const std::string& code, const std::unique_ptr& func_registry) { ProgramAstBuilder ast_builder; std::unique_ptr program_ast; JF_RETURN_NOT_OK(ast_builder.BuildExpression(code, &program_ast)); - return exec_engine_.Compile(program_ast, func_registry); + return engine_.Compile(program_ast, func_registry); } -Status Athena::Execute(void* entry_arguments, RetType* result) { return exec_engine_.Execute(entry_arguments, result); } - -Status Athena::Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result) { - return exec_engine_.Execute(exec_ctx, entry_arguments, result); -} - -Status Athena::Compile(const std::vector& code, const std::unique_ptr& func_registry) { +Status AthenaPipeline::Compile(const std::vector& code, + const std::unique_ptr& func_registry) { ProgramAstBuilder ast_builder; std::vector> program_asts; for (const auto& code_str : code) { @@ -36,13 +32,7 @@ Status Athena::Compile(const std::vector& code, const std::unique_p } PipelineGrouper pipeline_grouper; std::vector> grouped_program_asts = pipeline_grouper.Group(program_asts); - return exec_engine_.BatchCompile(grouped_program_asts, func_registry); -} - -Status Athena::Execute(void* entry_arguments, void* result) { return exec_engine_.ExecuteAll(entry_arguments, result); } - -Status Athena::Execute(ExecContext& exec_ctx, void* entry_arguments, void* result) { - return exec_engine_.ExecuteAll(exec_ctx, entry_arguments, result); + return engine_.Compile(grouped_program_asts, func_registry); } -} // namespace athena \ No newline at end of file +} // namespace athena diff --git a/athena/athena.h b/athena/athena.h index c193ffe..9b29a83 100644 --- a/athena/athena.h +++ b/athena/athena.h @@ -2,12 +2,16 @@ * @Author: victorika * @Date: 2025-04-09 15:43:45 * @Last Modified by: victorika - * @Last Modified time: 2026-03-31 14:56:23 + * @Last Modified time: 2026-05-08 10:00:00 */ #pragma once #include +#include +#include +#include #include "arena.h" +#include "batch_exec_engine.h" #include "exec_engine.h" #include "function_registry.h" #include "status.h" @@ -16,6 +20,7 @@ namespace athena { using jitfusion::Arena; +using jitfusion::BatchExecEngine; using jitfusion::BinaryOPType; using jitfusion::CodeGenFunc; using jitfusion::ConstantListValueType; @@ -49,42 +54,89 @@ using jitfusion::U8ListStruct; using jitfusion::UnaryOPType; using jitfusion::ValueType; -// Thread-safety contract (mirrors the underlying ExecEngine): -// - Compile() is NOT thread-safe and must not run concurrently with any other -// method on the same Athena instance. -// - After a successful Compile(), the Execute() overloads are safe to invoke -// concurrently from multiple threads on the same Athena instance, provided -// each thread uses its own ExecContext. -// - The Execute() overloads that do not take an ExecContext internally construct -// a fresh one on every call; they are thread-safe but allocate per call. -// Prefer the ExecContext& overloads on hot paths to reuse the arena. -// - A single ExecContext must NOT be shared across threads. Recommended pattern -// for parallel execution: 1 Athena + N ExecContexts (one per worker). -class Athena { +// AthenaExpression compiles and runs a single DSL expression. The result +// is returned through the RetType variant. This is the simplest form of +// usage — "one line of athena DSL, one value out". +// +// For multi-statement programs that write data through custom store +// functions (the pipeline form), use AthenaPipeline below. +// +// Thread-safety contract (mirrors ExecEngine): +// - Compile() is NOT thread-safe. +// - After a successful Compile(), the Execute() overloads are safe to +// invoke concurrently from multiple threads, provided each thread uses +// its own ExecContext. +// - The Execute() overloads that do not take an ExecContext internally +// construct a fresh one per call (thread-safe but pay per-call +// allocation cost). Prefer the ExecContext& overloads on hot paths. +// - A single ExecContext must NOT be shared across threads. Recommended +// pattern for parallel execution: 1 AthenaExpression + N ExecContexts +// (one per worker). +class AthenaExpression { public: - explicit Athena(ExecEngineOption option = {}) : exec_engine_(option) {} - ~Athena() = default; - Athena(const Athena&) = delete; - Athena& operator=(const Athena&) = delete; + explicit AthenaExpression(ExecEngineOption option = {}) : engine_(option) {} + ~AthenaExpression() = default; + AthenaExpression(const AthenaExpression&) = delete; + AthenaExpression& operator=(const AthenaExpression&) = delete; - // Applicable to simple scenarios, the program will not actually use a custom store function to write data. Instead, - // the result will be returned, similar to expression scenarios. - // If you need to optimize the memory allocation issue of ExecContext, you can use the function passed to ExecContext. + // Compile a single DSL expression into an executable entry function. Status Compile(const std::string& code, const std::unique_ptr& func_registry); - Status Execute(void* entry_arguments, RetType* result); - Status Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result); - // Applicable to complex scenarios where multiple pipelines are computed simultaneously. Each pipeline writes data - // using a custom function, and results are not returned. This is similar to feature processing scenarios. - // If you need to optimize the memory allocation issue of ExecContext, you can use the function passed to ExecContext. + // Run the compiled expression and box the result into RetType. + Status Execute(void* entry_arguments, RetType* result) { return engine_.Execute(entry_arguments, result); } + Status Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result) { + return engine_.Execute(exec_ctx, entry_arguments, result); + } + + [[nodiscard]] std::string_view GetIRCode() const { return engine_.GetIRCode(); } + + private: + ExecEngine engine_; +}; + +// AthenaPipeline compiles a multi-statement DSL program into a batch of +// entry functions that share one JIT module. Pipelines do not return a +// value through RetType — they write their results via user-supplied +// store functions registered through RegisterStoreCFunc. This matches +// feature-processing / columnar-store scenarios. +// +// For the simpler "one expression, one return value" form, use +// AthenaExpression above. +// +// Thread-safety contract (mirrors BatchExecEngine): +// - Compile() is NOT thread-safe. +// - After a successful Compile(), the Execute() overloads are safe to +// invoke concurrently from multiple threads, provided each thread uses +// its own ExecContext. +// - The Execute() overloads that do not take an ExecContext internally +// construct a fresh one per call (thread-safe but pay per-call +// allocation cost). Prefer the ExecContext& overloads on hot paths. +// - A single ExecContext must NOT be shared across threads. Recommended +// pattern for parallel execution: 1 AthenaPipeline + N ExecContexts +// (one per worker). +class AthenaPipeline { + public: + explicit AthenaPipeline(ExecEngineOption option = {}) : engine_(option) {} + ~AthenaPipeline() = default; + AthenaPipeline(const AthenaPipeline&) = delete; + AthenaPipeline& operator=(const AthenaPipeline&) = delete; + + // Compile a list of DSL pipeline statements. The grouper merges + // statements that share inputs; every group becomes one entry in the + // underlying BatchExecEngine. Status Compile(const std::vector& code, const std::unique_ptr& func_registry); - Status Execute(void* entry_arguments, void* result); - Status Execute(ExecContext& exec_ctx, void* entry_arguments, void* result); - [[nodiscard]] std::string_view GetIRCode() const { return exec_engine_.GetIRCode(); } + // Run every compiled entry in order, forwarding `result` to each entry's + // user store functions. + Status Execute(void* entry_arguments, void* result) { return engine_.ExecuteAll(entry_arguments, result); } + Status Execute(ExecContext& exec_ctx, void* entry_arguments, void* result) { + return engine_.ExecuteAll(exec_ctx, entry_arguments, result); + } + + [[nodiscard]] std::string_view GetIRCode() const { return engine_.GetIRCode(); } private: - ExecEngine exec_engine_; + BatchExecEngine engine_; }; -} // namespace athena \ No newline at end of file +} // namespace athena diff --git a/athena/test/const_value_test.cc b/athena/test/const_value_test.cc index b83c395..f11961e 100644 --- a/athena/test/const_value_test.cc +++ b/athena/test/const_value_test.cc @@ -2,13 +2,13 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::RetType; TEST(ConstValueTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile("r = 42;", func_registry).ok()); @@ -18,7 +18,7 @@ TEST(ConstValueTest, Test1) { } TEST(ConstValueTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile("r = 42f64;", func_registry).ok()); @@ -28,7 +28,7 @@ TEST(ConstValueTest, Test2) { } TEST(ConstValueTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile("r = [1, 2, 3];", func_registry).ok()); @@ -40,7 +40,7 @@ TEST(ConstValueTest, Test3) { } TEST(ConstValueTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = "abcde";)", func_registry).ok()); @@ -50,7 +50,7 @@ TEST(ConstValueTest, Test4) { } TEST(ConstValueTest, ListMergeOptimizeTest) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -68,7 +68,7 @@ TEST(ConstValueTest, ListMergeOptimizeTest) { } TEST(StringAddTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE( diff --git a/athena/test/control_flow_test.cc b/athena/test/control_flow_test.cc index dc25933..247d121 100644 --- a/athena/test/control_flow_test.cc +++ b/athena/test/control_flow_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -10,7 +10,7 @@ using athena::ValueType; using test::LoadF32; TEST(SwitchTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -28,7 +28,7 @@ TEST(SwitchTest, Test1) { } TEST(SwitchTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -46,7 +46,7 @@ TEST(SwitchTest, Test2) { } TEST(SwitchTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -67,7 +67,7 @@ TEST(SwitchTest, Test3) { } TEST(SwitchTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -80,7 +80,7 @@ TEST(SwitchTest, Test4) { } TEST(NestedIfTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -98,7 +98,7 @@ TEST(NestedIfTest, Test1) { } TEST(NestedIfTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -116,7 +116,7 @@ TEST(NestedIfTest, Test2) { } TEST(NestedIfTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -135,7 +135,7 @@ TEST(NestedIfTest, Test3) { } TEST(NestedIfTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -153,7 +153,7 @@ TEST(NestedIfTest, Test4) { } TEST(NestedSwitchTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -171,7 +171,7 @@ TEST(NestedSwitchTest, Test1) { } TEST(NestedSwitchTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -189,7 +189,7 @@ TEST(NestedSwitchTest, Test2) { } TEST(NestedSwitchTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); diff --git a/athena/test/cse_test.cc b/athena/test/cse_test.cc index 68bcbf2..55da3e8 100644 --- a/athena/test/cse_test.cc +++ b/athena/test/cse_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaPipeline; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -39,7 +39,7 @@ float CountedTransformF32(void* entry_arguments, float a) { } // namespace TEST(CSETest, SamePipelineRefNodeReuse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -100,7 +100,7 @@ TEST(CSETest, SamePipelineRefNodeReuse) { } TEST(CSETest, MultiplePipelinesLoadMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -142,7 +142,7 @@ TEST(CSETest, MultiplePipelinesLoadMerge) { } TEST(CSETest, ThreePipelinesLoadMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -185,7 +185,7 @@ TEST(CSETest, ThreePipelinesLoadMerge) { } TEST(CSETest, ReadOnlyComputeFunctionMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -232,7 +232,7 @@ TEST(CSETest, ReadOnlyComputeFunctionMerge) { } TEST(CSETest, DifferentArgsNoMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -270,7 +270,7 @@ TEST(CSETest, DifferentArgsNoMerge) { } TEST(CSETest, ChainedReadOnlyFunctionMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -314,7 +314,7 @@ TEST(CSETest, ChainedReadOnlyFunctionMerge) { } TEST(CSETest, PartialMerge) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -370,7 +370,7 @@ TEST(CSETest, PartialMerge) { } TEST(CSETest, ComplexPipelineCSE) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { diff --git a/athena/test/diagnostic_test.cc b/athena/test/diagnostic_test.cc index 8c6b498..f213729 100644 --- a/athena/test/diagnostic_test.cc +++ b/athena/test/diagnostic_test.cc @@ -9,7 +9,8 @@ #include "function_registry.h" #include "gtest/gtest.h" -using athena::Athena; +using athena::AthenaExpression; +using athena::AthenaPipeline; using jitfusion::Diagnostic; using jitfusion::FunctionRegistry; using jitfusion::FunctionRegistryFactory; @@ -62,7 +63,7 @@ TEST(DiagnosticTest, RenderWithEmptySourceFallsBack) { } TEST(DiagnosticTest, UndefinedVariableProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = a + 1;"; // 'a' is undefined auto st = athena.Compile(code, reg); @@ -74,7 +75,7 @@ TEST(DiagnosticTest, UndefinedVariableProducesSourceContext) { } TEST(DiagnosticTest, IfBranchTypeMismatchProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = if(1, 2, \"hi\");"; auto st = athena.Compile(code, reg); @@ -87,7 +88,7 @@ TEST(DiagnosticTest, IfBranchTypeMismatchProducesSourceContext) { } TEST(DiagnosticTest, DivByZeroProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = 10 / 0;"; auto st = athena.Compile(code, reg); @@ -97,7 +98,7 @@ TEST(DiagnosticTest, DivByZeroProducesSourceContext) { } TEST(DiagnosticTest, LogicalOpOnStringsProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = "hi" and "world";)"; auto st = athena.Compile(code, reg); @@ -110,7 +111,7 @@ TEST(DiagnosticTest, LogicalOpOnStringsProducesSourceContext) { } TEST(DiagnosticTest, BitwiseNotOnFloatProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = ~1.5f32;"; auto st = athena.Compile(code, reg); @@ -123,7 +124,7 @@ TEST(DiagnosticTest, BitwiseNotOnFloatProducesSourceContext) { } TEST(DiagnosticTest, UnaryMinusOnStringProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = -"hi";)"; auto st = athena.Compile(code, reg); @@ -135,7 +136,7 @@ TEST(DiagnosticTest, UnaryMinusOnStringProducesSourceContext) { } TEST(DiagnosticTest, IfWrongArityProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = if(1, 2);"; auto st = athena.Compile(code, reg); @@ -147,7 +148,7 @@ TEST(DiagnosticTest, IfWrongArityProducesSourceContext) { } TEST(DiagnosticTest, IfConditionNotNumericProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = if("hi", 1, 2);)"; auto st = athena.Compile(code, reg); @@ -160,7 +161,7 @@ TEST(DiagnosticTest, IfConditionNotNumericProducesSourceContext) { } TEST(DiagnosticTest, UnknownFunctionProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = definitely_not_a_function(1);"; auto st = athena.Compile(code, reg); @@ -172,7 +173,7 @@ TEST(DiagnosticTest, UnknownFunctionProducesSourceContext) { } TEST(DiagnosticTest, RelationalStringVsNumericProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = "hi" < 3;)"; auto st = athena.Compile(code, reg); @@ -185,7 +186,7 @@ TEST(DiagnosticTest, RelationalStringVsNumericProducesSourceContext) { } TEST(DiagnosticTest, RelationalStringVsListProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = "hi" < [1, 2, 3];)"; auto st = athena.Compile(code, reg); @@ -196,7 +197,7 @@ TEST(DiagnosticTest, RelationalStringVsListProducesSourceContext) { } TEST(DiagnosticTest, ArithmeticStringSubProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = "hi" - "ho";)"; auto st = athena.Compile(code, reg); @@ -209,7 +210,7 @@ TEST(DiagnosticTest, ArithmeticStringSubProducesSourceContext) { } TEST(DiagnosticTest, ArithmeticStringMulProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = "hi" * 3;)"; auto st = athena.Compile(code, reg); @@ -221,7 +222,7 @@ TEST(DiagnosticTest, ArithmeticStringMulProducesSourceContext) { } TEST(DiagnosticTest, BitwiseOnFloatProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = 1 & 1.0f32;"; auto st = athena.Compile(code, reg); @@ -234,7 +235,7 @@ TEST(DiagnosticTest, BitwiseOnFloatProducesSourceContext) { } TEST(DiagnosticTest, AddListMismatchProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = [1, 2] + [1.0f32, 2.0f32];"; auto st = athena.Compile(code, reg); @@ -245,7 +246,7 @@ TEST(DiagnosticTest, AddListMismatchProducesSourceContext) { } TEST(DiagnosticTest, AddListAndScalarProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = "r = [1, 2] + 3;"; auto st = athena.Compile(code, reg); @@ -258,7 +259,7 @@ TEST(DiagnosticTest, AddListAndScalarProducesSourceContext) { TEST(DiagnosticTest, DemoRenderedOutput) { auto reg = MakeRegistry(); { - Athena athena; + AthenaExpression athena; std::string code = R"(a = 10; b = a + 1; c = d + 5; @@ -270,19 +271,19 @@ c = d + 5; EXPECT_NE(st.ToString().find("line 3"), std::string::npos); } { - Athena athena; + AthenaExpression athena; auto st = athena.Compile("r = if(1, 2, \"hi\");", reg); ASSERT_FALSE(st.ok()); GTEST_LOG_(INFO) << "\n--- if branches mismatch ---\n" << st.ToString(); } { - Athena athena; + AthenaExpression athena; auto st = athena.Compile("r = 10 / 0;", reg); ASSERT_FALSE(st.ok()); GTEST_LOG_(INFO) << "\n--- div by zero ---\n" << st.ToString(); } { - Athena athena; + AthenaExpression athena; auto st = athena.Compile(R"(r = "hi" and "world";)", reg); ASSERT_FALSE(st.ok()); GTEST_LOG_(INFO) << "\n--- logical op on strings ---\n" << st.ToString(); @@ -290,7 +291,7 @@ c = d + 5; } TEST(DiagnosticTest, PipelineUndefinedVariableProducesSourceContext) { - Athena athena; + AthenaPipeline athena; auto reg = MakeRegistry(); std::string code = R"(a = 10; b = a + 1; @@ -308,7 +309,7 @@ c = d + 5; } TEST(DiagnosticTest, MultiPipelineErrorAnchorsToOwningPipeline) { - Athena athena; + AthenaPipeline athena; auto reg = MakeRegistry(); std::string ok_code = R"(x = 1; y = x + 2; @@ -330,7 +331,7 @@ q = p + zzz; } TEST(DiagnosticTest, MultiPipelineCompileAndExecuteHappyPath) { - Athena athena; + AthenaPipeline athena; auto reg = MakeRegistry(); { jitfusion::FunctionSignature sign("load", {jitfusion::ValueType::kPtr, jitfusion::ValueType::kI32}, @@ -373,7 +374,7 @@ TEST(DiagnosticTest, MultiPipelineCompileAndExecuteHappyPath) { } TEST(DiagnosticTest, SwitchEvenArityProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); // switch requires (cond, then, ..., default) -> odd arg count; this has 4. std::string code = "r = switch(1, 2, 3, 4);"; @@ -386,7 +387,7 @@ TEST(DiagnosticTest, SwitchEvenArityProducesSourceContext) { } TEST(DiagnosticTest, SwitchConditionNotNumericProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = switch("hi", 1, 2);)"; auto st = athena.Compile(code, reg); @@ -399,7 +400,7 @@ TEST(DiagnosticTest, SwitchConditionNotNumericProducesSourceContext) { } TEST(DiagnosticTest, SwitchIncompatibleBranchTypesProducesSourceContext) { - Athena athena; + AthenaExpression athena; auto reg = MakeRegistry(); std::string code = R"(r = switch(1, "hi", 2);)"; auto st = athena.Compile(code, reg); @@ -435,7 +436,7 @@ std::unique_ptr MakeRegistryWithLoadStore() { } // namespace TEST(DiagnosticTest, IfBlockConditionNotNumericProducesSourceContext) { - Athena athena; + AthenaPipeline athena; auto reg = MakeRegistryWithLoadStore(); std::string code = R"(r = 0.0f32; when "hello" { @@ -454,7 +455,7 @@ store(output, 0, r); } TEST(DiagnosticTest, IfBlockVariableTypeMismatchProducesSourceContext) { - Athena athena; + AthenaPipeline athena; auto reg = MakeRegistryWithLoadStore(); std::string code = R"(r = 0.0f32; when r > 0.0f32 { diff --git a/athena/test/exec_error_test.cc b/athena/test/exec_error_test.cc index 84e6d23..ff9af00 100644 --- a/athena/test/exec_error_test.cc +++ b/athena/test/exec_error_test.cc @@ -2,7 +2,8 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; +using athena::AthenaPipeline; using athena::ExecContext; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; @@ -14,7 +15,7 @@ using test::LoadF32; using test::StoreF32; TEST(ExecErrorTest, SingleExpressionRuntimeError) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -30,7 +31,7 @@ TEST(ExecErrorTest, SingleExpressionRuntimeError) { } TEST(ExecErrorTest, WithExecContextRuntimeError) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -48,7 +49,7 @@ TEST(ExecErrorTest, WithExecContextRuntimeError) { } TEST(ExecErrorTest, BatchExecutePartialFailure) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { diff --git a/athena/test/function_test.cc b/athena/test/function_test.cc index c1c5cc1..9f43cd4 100644 --- a/athena/test/function_test.cc +++ b/athena/test/function_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -12,7 +12,7 @@ using test::LoadI32; using test::LoadU32; TEST(FunctionTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -25,7 +25,7 @@ TEST(FunctionTest, Test1) { } TEST(FunctionTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -38,7 +38,7 @@ TEST(FunctionTest, Test2) { } TEST(FunctionTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -51,7 +51,7 @@ TEST(FunctionTest, Test3) { } TEST(FunctionTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -64,7 +64,7 @@ TEST(FunctionTest, Test4) { } TEST(FunctionTest, Test5) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -77,7 +77,7 @@ TEST(FunctionTest, Test5) { } TEST(FunctionTest, Test6) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -90,7 +90,7 @@ TEST(FunctionTest, Test6) { } TEST(FunctionTest, Test7) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -103,7 +103,7 @@ TEST(FunctionTest, Test7) { } TEST(FunctionTest, Test8) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -116,7 +116,7 @@ TEST(FunctionTest, Test8) { } TEST(FunctionTest, Test9) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -129,7 +129,7 @@ TEST(FunctionTest, Test9) { } TEST(FunctionTest, Test10) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -142,7 +142,7 @@ TEST(FunctionTest, Test10) { } TEST(FunctionTest, Test11) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -155,7 +155,7 @@ TEST(FunctionTest, Test11) { } TEST(FunctionTest, Test12) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -168,7 +168,7 @@ TEST(FunctionTest, Test12) { } TEST(FunctionTest, Test13) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -186,7 +186,7 @@ TEST(FunctionTest, Test13) { } TEST(FunctionTest, Test14) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -199,7 +199,7 @@ TEST(FunctionTest, Test14) { } TEST(FunctionTest, Test15) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -217,7 +217,7 @@ TEST(FunctionTest, Test15) { } TEST(FunctionTest, Test16) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -235,7 +235,7 @@ TEST(FunctionTest, Test16) { } TEST(FunctionTest, Test17) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -248,7 +248,7 @@ TEST(FunctionTest, Test17) { } TEST(FunctionTest, Test18) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -265,7 +265,7 @@ TEST(FunctionTest, Test18) { } TEST(FunctionTest, Test19) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -282,7 +282,7 @@ TEST(FunctionTest, Test19) { } TEST(FunctionTest, Test20) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -300,7 +300,7 @@ TEST(FunctionTest, Test20) { } TEST(FunctionTest, Test21) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -313,7 +313,7 @@ TEST(FunctionTest, Test21) { } TEST(FunctionTest, Test22) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -331,7 +331,7 @@ TEST(FunctionTest, Test22) { } TEST(FunctionTest, Test23) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -349,7 +349,7 @@ TEST(FunctionTest, Test23) { } TEST(FunctionTest, Test24) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -362,7 +362,7 @@ TEST(FunctionTest, Test24) { } TEST(FunctionTest, Test25) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -380,7 +380,7 @@ TEST(FunctionTest, Test25) { } TEST(FunctionTest, Test26) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); diff --git a/athena/test/list_function_test.cc b/athena/test/list_function_test.cc index bbd6322..d945a37 100644 --- a/athena/test/list_function_test.cc +++ b/athena/test/list_function_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -12,7 +12,7 @@ using test::LoadI32List; using test::LoadStringList; TEST(ListFunctionTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -31,7 +31,7 @@ TEST(ListFunctionTest, Test1) { } TEST(ListFunctionTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -50,7 +50,7 @@ TEST(ListFunctionTest, Test2) { } TEST(ListFunctionTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -69,7 +69,7 @@ TEST(ListFunctionTest, Test3) { } TEST(ListFunctionTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -87,7 +87,7 @@ TEST(ListFunctionTest, Test4) { } TEST(ListFunctionTest, Test5) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kStringList); @@ -106,7 +106,7 @@ TEST(ListFunctionTest, Test5) { } TEST(ListFunctionTest, Test6) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kStringList); @@ -124,7 +124,7 @@ TEST(ListFunctionTest, Test6) { } TEST(ListFunctionTest, Test7) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF64List); @@ -142,7 +142,7 @@ TEST(ListFunctionTest, Test7) { } TEST(ListFunctionTest, Test8) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF64List); diff --git a/athena/test/logical_op_test.cc b/athena/test/logical_op_test.cc index 3c0b0e0..c2b7687 100644 --- a/athena/test/logical_op_test.cc +++ b/athena/test/logical_op_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -11,7 +11,7 @@ using test::LoadF32; using test::LoadI32; TEST(LogicalOpTest, ChainedAnd) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 1 and 2 and 3;)", func_registry).ok()); @@ -21,7 +21,7 @@ TEST(LogicalOpTest, ChainedAnd) { } TEST(LogicalOpTest, ChainedAndShortCircuit) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 1 and 0 and 3;)", func_registry).ok()); @@ -31,7 +31,7 @@ TEST(LogicalOpTest, ChainedAndShortCircuit) { } TEST(LogicalOpTest, ChainedOrAllFalse) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 0 or 0 or 0;)", func_registry).ok()); @@ -41,7 +41,7 @@ TEST(LogicalOpTest, ChainedOrAllFalse) { } TEST(LogicalOpTest, ChainedOrShortCircuit) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 0 or 5 or 0;)", func_registry).ok()); @@ -51,7 +51,7 @@ TEST(LogicalOpTest, ChainedOrShortCircuit) { } TEST(LogicalOpTest, MixedAndOr1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = (1 and 0) or (1 and 1);)", func_registry).ok()); @@ -61,7 +61,7 @@ TEST(LogicalOpTest, MixedAndOr1) { } TEST(LogicalOpTest, MixedAndOr2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = (0 or 1) and (0 or 0);)", func_registry).ok()); @@ -71,7 +71,7 @@ TEST(LogicalOpTest, MixedAndOr2) { } TEST(LogicalOpTest, LogicalWithArithmetic) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -89,7 +89,7 @@ TEST(LogicalOpTest, LogicalWithArithmetic) { } TEST(LogicalOpTest, LogicalWithArithmeticFalse) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -107,7 +107,7 @@ TEST(LogicalOpTest, LogicalWithArithmeticFalse) { } TEST(LogicalOpTest, LogicalWithNot) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = not (1 and 0) or 0;)", func_registry).ok()); @@ -117,7 +117,7 @@ TEST(LogicalOpTest, LogicalWithNot) { } TEST(LogicalOpTest, DeepNestedLogical) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = ((1 and 1) or (0 and 1)) and (0 or 1);)", func_registry).ok()); @@ -127,7 +127,7 @@ TEST(LogicalOpTest, DeepNestedLogical) { } TEST(LogicalOpTest, DeepNestedLogicalAllShortCircuit) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = ((0 and 1) or (0 and 1)) and (1 or 0);)", func_registry).ok()); @@ -137,7 +137,7 @@ TEST(LogicalOpTest, DeepNestedLogicalAllShortCircuit) { } TEST(LogicalOpTest, FloatChainedLogical) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 1.5 and 2.5 and 0.0;)", func_registry).ok()); @@ -147,7 +147,7 @@ TEST(LogicalOpTest, FloatChainedLogical) { } TEST(LogicalOpTest, FloatChainedOr) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 0.0 or 0.0 or 3.14;)", func_registry).ok()); @@ -157,7 +157,7 @@ TEST(LogicalOpTest, FloatChainedOr) { } TEST(LogicalOpTest, LogicalResultInArithmetic) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -175,7 +175,7 @@ TEST(LogicalOpTest, LogicalResultInArithmetic) { } TEST(LogicalOpTest, LogicalInIfCondition) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -193,7 +193,7 @@ TEST(LogicalOpTest, LogicalInIfCondition) { } TEST(LogicalOpTest, LogicalInIfConditionFalse) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -211,7 +211,7 @@ TEST(LogicalOpTest, LogicalInIfConditionFalse) { } TEST(LogicalOpTest, LogicalInSwitch) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -229,7 +229,7 @@ TEST(LogicalOpTest, LogicalInSwitch) { } TEST(LogicalOpTest, ComplexMultiVarLogical) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -252,7 +252,7 @@ TEST(LogicalOpTest, ComplexMultiVarLogical) { } TEST(LogicalOpTest, ComplexMultiVarLogical2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -275,7 +275,7 @@ TEST(LogicalOpTest, ComplexMultiVarLogical2) { } TEST(LogicalOpTest, LongChainComparison) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -295,7 +295,7 @@ TEST(LogicalOpTest, LongChainComparison) { } TEST(LogicalOpTest, LongChainComparisonBreak) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -315,7 +315,7 @@ TEST(LogicalOpTest, LongChainComparisonBreak) { } TEST(LogicalOpTest, LongChainOr) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -335,7 +335,7 @@ TEST(LogicalOpTest, LongChainOr) { } TEST(LogicalOpTest, LongChainOrAllFalse) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32); @@ -355,7 +355,7 @@ TEST(LogicalOpTest, LongChainOrAllFalse) { } TEST(LogicalOpTest, LogicalWithFunctionCalls) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -373,7 +373,7 @@ TEST(LogicalOpTest, LogicalWithFunctionCalls) { } TEST(LogicalOpTest, LogicalInSwitchMultiConditions) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -396,7 +396,7 @@ TEST(LogicalOpTest, LogicalInSwitchMultiConditions) { } TEST(LogicalOpTest, StringAndReject) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto st = athena.Compile(R"(r = "hello" and "world";)", func_registry); @@ -405,7 +405,7 @@ TEST(LogicalOpTest, StringAndReject) { } TEST(LogicalOpTest, StringOrReject) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto st = athena.Compile(R"(r = "hello" or "world";)", func_registry); diff --git a/athena/test/operator_test.cc b/athena/test/operator_test.cc index e559869..76f6987 100644 --- a/athena/test/operator_test.cc +++ b/athena/test/operator_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -11,7 +11,7 @@ using test::LoadF32; using test::LoadU32; TEST(UnaryOperatorTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = -42;)", func_registry).ok()); @@ -21,7 +21,7 @@ TEST(UnaryOperatorTest, Test1) { } TEST(UnaryOperatorTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = ~42;)", func_registry).ok()); @@ -31,7 +31,7 @@ TEST(UnaryOperatorTest, Test2) { } TEST(UnaryOperatorTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = not 99;)", func_registry).ok()); @@ -41,7 +41,7 @@ TEST(UnaryOperatorTest, Test3) { } TEST(UnaryOperatorTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = !0;)", func_registry).ok()); @@ -51,7 +51,7 @@ TEST(UnaryOperatorTest, Test4) { } TEST(BinaryOperatorTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 0 and 1;)", func_registry).ok()); @@ -61,7 +61,7 @@ TEST(BinaryOperatorTest, Test1) { } TEST(BinaryOperatorTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ASSERT_TRUE(athena.Compile(R"(r = 0 || 1;)", func_registry).ok()); @@ -71,7 +71,7 @@ TEST(BinaryOperatorTest, Test2) { } TEST(BinaryOperatorTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -89,7 +89,7 @@ TEST(BinaryOperatorTest, Test3) { } TEST(BinaryOperatorTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -107,7 +107,7 @@ TEST(BinaryOperatorTest, Test4) { } TEST(BinaryOperatorTest, Test5) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -125,7 +125,7 @@ TEST(BinaryOperatorTest, Test5) { } TEST(BinaryOperatorTest, Test6) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -143,7 +143,7 @@ TEST(BinaryOperatorTest, Test6) { } TEST(BinaryOperatorTest, Test7) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -161,7 +161,7 @@ TEST(BinaryOperatorTest, Test7) { } TEST(BinaryOperatorTest, Test8) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -179,7 +179,7 @@ TEST(BinaryOperatorTest, Test8) { } TEST(BinaryOperatorTest, Test9) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -197,7 +197,7 @@ TEST(BinaryOperatorTest, Test9) { } TEST(BinaryOperatorTest, Test10) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kU32); @@ -216,7 +216,7 @@ TEST(BinaryOperatorTest, Test10) { } TEST(BinaryOperatorTest, Test11) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -229,7 +229,7 @@ TEST(BinaryOperatorTest, Test11) { } TEST(BinaryOperatorTest, Test12) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -242,7 +242,7 @@ TEST(BinaryOperatorTest, Test12) { } TEST(BinaryOperatorTest, Test13) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -255,7 +255,7 @@ TEST(BinaryOperatorTest, Test13) { } TEST(BinaryOperatorTest, Test14) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -268,7 +268,7 @@ TEST(BinaryOperatorTest, Test14) { } TEST(BinaryOperatorTest, Test15) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -281,7 +281,7 @@ TEST(BinaryOperatorTest, Test15) { } TEST(BinaryOperatorTest, Test16) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -294,7 +294,7 @@ TEST(BinaryOperatorTest, Test16) { } TEST(BinaryOperatorTest, Test17) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( @@ -307,7 +307,7 @@ TEST(BinaryOperatorTest, Test17) { } TEST(BinaryOperatorTest, Test18) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); std::string code = R"( diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index d66e2ee..c95cff4 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -1,7 +1,8 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; +using athena::AthenaPipeline; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -12,7 +13,7 @@ using test::LoadI32List; using test::StoreF32; TEST(MixTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -29,7 +30,7 @@ TEST(MixTest, Test1) { } TEST(ComplexTest, Test1) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -67,7 +68,7 @@ TEST(ComplexTest, Test1) { } TEST(FilterTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -86,7 +87,7 @@ TEST(FilterTest, Test1) { } TEST(FilterTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -107,7 +108,7 @@ TEST(FilterTest, Test2) { } TEST(CustomPassTest, CommutativeCallCanonicalizerPass1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -128,7 +129,7 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass1) { } TEST(CustomPassTest, CommutativeCallCanonicalizerPass2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kI32List); @@ -149,7 +150,7 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass2) { } TEST(PipelineGrouperTest, ThreeGroupTest) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -216,7 +217,7 @@ TEST(PipelineGrouperTest, ThreeGroupTest) { } TEST(ComplexTest, TwoStoreInSingleCode) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -247,7 +248,7 @@ TEST(ComplexTest, TwoStoreInSingleCode) { } TEST(IsolatedScopeTest, SameVarNameDifferentComputation) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -285,7 +286,7 @@ TEST(IsolatedScopeTest, SameVarNameDifferentComputation) { } TEST(IsolatedScopeTest, SameIntermediateVarDifferentChain) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -334,7 +335,7 @@ TEST(IsolatedScopeTest, SameIntermediateVarDifferentChain) { } TEST(IsolatedScopeTest, CrossPipelineVarReferenceError) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -364,7 +365,7 @@ TEST(IsolatedScopeTest, CrossPipelineVarReferenceError) { } TEST(IsolatedScopeTest, SameVarNameDifferentLoadIndex) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -407,7 +408,7 @@ TEST(IsolatedScopeTest, SameVarNameDifferentLoadIndex) { } TEST(IsolatedScopeTest, SameVarNameWithWhenBlock) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -449,7 +450,7 @@ TEST(IsolatedScopeTest, SameVarNameWithWhenBlock) { } TEST(IsolatedScopeTest, SameVarNameWithWhenElifElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -499,7 +500,7 @@ TEST(IsolatedScopeTest, SameVarNameWithWhenElifElse) { } TEST(IsolatedScopeTest, FourPipelinesSameVarNames) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -553,7 +554,7 @@ TEST(IsolatedScopeTest, FourPipelinesSameVarNames) { } TEST(IsolatedScopeTest, DifferentGroupsSameVarNames) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -606,7 +607,7 @@ TEST(IsolatedScopeTest, DifferentGroupsSameVarNames) { } TEST(IsolatedScopeTest, SameVarNameWithNestedWhen) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -654,7 +655,7 @@ TEST(IsolatedScopeTest, SameVarNameWithNestedWhen) { } TEST(IsolatedScopeTest, SameVarNameStoreInsideWhen) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -696,7 +697,7 @@ TEST(IsolatedScopeTest, SameVarNameStoreInsideWhen) { } TEST(ExecContextTest, ExpressionModeWithExecContext) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -723,7 +724,7 @@ TEST(ExecContextTest, ExpressionModeWithExecContext) { } TEST(ExecContextTest, PipelineModeWithExecContext) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { diff --git a/athena/test/ref_node_test.cc b/athena/test/ref_node_test.cc index 0dcb6ef..8e1fb7c 100644 --- a/athena/test/ref_node_test.cc +++ b/athena/test/ref_node_test.cc @@ -1,7 +1,8 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; +using athena::AthenaPipeline; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -12,7 +13,7 @@ using test::LoadI32List; using test::StoreF32; TEST(RefNodeTest, BasicVariableReference) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -45,7 +46,7 @@ TEST(RefNodeTest, BasicVariableReference) { } TEST(RefNodeTest, ChainedVariableReference) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -77,7 +78,7 @@ TEST(RefNodeTest, ChainedVariableReference) { } TEST(RefNodeTest, MultipleReferencesToSameVariable) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -112,7 +113,7 @@ TEST(RefNodeTest, MultipleReferencesToSameVariable) { } TEST(RefNodeTest, RefNodeWithIfAndSwitch) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -145,7 +146,7 @@ TEST(RefNodeTest, RefNodeWithIfAndSwitch) { } TEST(RefNodeTest, RefNodeWithFunctionCalls) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -178,7 +179,7 @@ TEST(RefNodeTest, RefNodeWithFunctionCalls) { } TEST(RefNodeTest, MultiplePipelinesWithRefNode) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -227,7 +228,7 @@ TEST(RefNodeTest, MultiplePipelinesWithRefNode) { } TEST(RefNodeTest, DeepChainReference) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -260,7 +261,7 @@ TEST(RefNodeTest, DeepChainReference) { } TEST(RefNodeTest, RefNodeWithListOperations) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -294,7 +295,7 @@ TEST(RefNodeTest, RefNodeWithListOperations) { } TEST(RefNodeTest, ExpressionModeStillUsesClone) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kF32); @@ -314,7 +315,7 @@ TEST(RefNodeTest, ExpressionModeStillUsesClone) { } TEST(RefNodeTest, ComplexPipelineWithLogicalAndRefNode) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -353,7 +354,7 @@ TEST(RefNodeTest, ComplexPipelineWithLogicalAndRefNode) { } TEST(RefNodeTest, UndefinedVariableReferenceError) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -378,7 +379,7 @@ TEST(RefNodeTest, UndefinedVariableReferenceError) { } TEST(RefNodeTest, UndefinedVariableInExpressionMode) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { diff --git a/athena/test/string_function_test.cc b/athena/test/string_function_test.cc index 284ecfe..7442400 100644 --- a/athena/test/string_function_test.cc +++ b/athena/test/string_function_test.cc @@ -1,7 +1,7 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -11,7 +11,7 @@ using test::LoadNullString; using test::LoadStr; TEST(StringFunctionTest, Test1) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -28,7 +28,7 @@ TEST(StringFunctionTest, Test1) { } TEST(StringFunctionTest, Test2) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -45,7 +45,7 @@ TEST(StringFunctionTest, Test2) { } TEST(StringFunctionTest, Test3) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -63,7 +63,7 @@ TEST(StringFunctionTest, Test3) { } TEST(StringFunctionTest, Test4) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -81,7 +81,7 @@ TEST(StringFunctionTest, Test4) { } TEST(StringFunctionTest, Test5) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -99,7 +99,7 @@ TEST(StringFunctionTest, Test5) { } TEST(StringFunctionTest, Test6) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {ValueType::kPtr, ValueType::kI32}, ValueType::kString); @@ -116,7 +116,7 @@ TEST(StringFunctionTest, Test6) { } TEST(StringFunctionTest, Test7) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); FunctionSignature sign("load", {}, ValueType::kString); diff --git a/athena/test/when_test.cc b/athena/test/when_test.cc index 3ad6766..259abe2 100644 --- a/athena/test/when_test.cc +++ b/athena/test/when_test.cc @@ -3,7 +3,8 @@ #include "gtest/gtest.h" #include "test_helper.h" -using athena::Athena; +using athena::AthenaExpression; +using athena::AthenaPipeline; using athena::FunctionRegistry; using athena::FunctionRegistryFactory; using athena::FunctionSignature; @@ -13,7 +14,7 @@ using test::LoadF32; using test::StoreF32; TEST(WhenTest, IfElseModifyMultipleVars) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -62,7 +63,7 @@ TEST(WhenTest, IfElseModifyMultipleVars) { } TEST(WhenTest, IfWithoutElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -102,7 +103,7 @@ TEST(WhenTest, IfWithoutElse) { } TEST(WhenTest, IfElifElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -153,7 +154,7 @@ TEST(WhenTest, IfElifElse) { } TEST(WhenTest, PartialModify) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -200,7 +201,7 @@ TEST(WhenTest, PartialModify) { } TEST(WhenTest, StoreInsideWhenElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -240,7 +241,7 @@ TEST(WhenTest, StoreInsideWhenElse) { } TEST(WhenTest, StoreInsideWhenElifElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -289,7 +290,7 @@ TEST(WhenTest, StoreInsideWhenElifElse) { } TEST(WhenTest, MixedModifyAndStoreInWhen) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -336,7 +337,7 @@ TEST(WhenTest, MixedModifyAndStoreInWhen) { } TEST(WhenTest, StoreToMultipleOutputsInElifChain) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -391,7 +392,7 @@ TEST(WhenTest, StoreToMultipleOutputsInElifChain) { } TEST(WhenTest, StoreInsideWhenWithoutElse) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -430,7 +431,7 @@ TEST(WhenTest, StoreInsideWhenWithoutElse) { } TEST(WhenTest, CompoundConditionsWithFunctions) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -501,7 +502,7 @@ TEST(WhenTest, CompoundConditionsWithFunctions) { } TEST(WhenTest, IntermediateVarsAndComplexExprInWhen) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -566,7 +567,7 @@ TEST(WhenTest, IntermediateVarsAndComplexExprInWhen) { } TEST(WhenTest, ConsecutiveWhenBlocks) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -622,7 +623,7 @@ TEST(WhenTest, ConsecutiveWhenBlocks) { } TEST(WhenTest, WhenMixedWithIfAndSwitchExpr) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -683,7 +684,7 @@ TEST(WhenTest, WhenMixedWithIfAndSwitchExpr) { } TEST(WhenTest, RateCalculationBusinessScenario) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -778,7 +779,7 @@ TEST(WhenTest, RateCalculationBusinessScenario) { } TEST(WhenTest, FunctionCallInCondition) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -838,7 +839,7 @@ TEST(WhenTest, FunctionCallInCondition) { } TEST(WhenTest, TwoLevelNesting) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -915,7 +916,7 @@ TEST(WhenTest, TwoLevelNesting) { } TEST(WhenTest, TwoLevelWithStoreAndMultipleOutputs) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -993,7 +994,7 @@ TEST(WhenTest, TwoLevelWithStoreAndMultipleOutputs) { } TEST(WhenTest, ThreeLevelNesting) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1095,7 +1096,7 @@ TEST(WhenTest, ThreeLevelNesting) { } TEST(WhenTest, FourLevelNesting) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1207,7 +1208,7 @@ TEST(WhenTest, FourLevelNesting) { } TEST(WhenTest, ThreeLevelModifyDifferentVars) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1312,7 +1313,7 @@ TEST(WhenTest, ThreeLevelModifyDifferentVars) { } TEST(WhenTest, ThreeLevelWithExpressions) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1377,7 +1378,7 @@ TEST(WhenTest, ThreeLevelWithExpressions) { } TEST(WhenTest, WhenBlockNotAllowedInExpressionMode) { - Athena athena; + AthenaExpression athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1400,7 +1401,7 @@ TEST(WhenTest, WhenBlockNotAllowedInExpressionMode) { } TEST(WhenTest, VariableTypeMismatchInWhenBranch) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1428,7 +1429,7 @@ TEST(WhenTest, VariableTypeMismatchInWhenBranch) { } TEST(WhenTest, VariableTypeMismatchInElseBranch) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { @@ -1458,7 +1459,7 @@ TEST(WhenTest, VariableTypeMismatchInElseBranch) { } TEST(WhenTest, StringConditionReject) { - Athena athena; + AthenaPipeline athena; std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); { diff --git a/benchmark/bench_common.h b/benchmark/bench_common.h index 31aeb95..f947ae2 100644 --- a/benchmark/bench_common.h +++ b/benchmark/bench_common.h @@ -39,15 +39,16 @@ #include #include +#include "batch_exec_engine.h" #include "exec_engine.h" #include "exec_node.h" #include "function_registry.h" #include "status.h" #include "type.h" -namespace jitfusion { -namespace bench { +namespace jitfusion::bench { +using ::jitfusion::BatchExecEngine; using ::jitfusion::BinaryOPNode; using ::jitfusion::BinaryOPType; using ::jitfusion::ConstantListValueNode; @@ -170,7 +171,7 @@ inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_n // Build `func_name(list, scalar, exec_ctx)` — bitwise list-scalar. // Bitwise kernels are only registered for unsigned integer types. inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& func_name, int list_len, - uint64_t scalar_val) { + uint64_t scalar_val) { std::vector values; values.reserve(list_len); for (int i = 0; i < list_len; ++i) { @@ -251,9 +252,7 @@ inline std::unique_ptr MakeRegistry() { // Must be `inline` so its address is unique across TUs that include this // header — the JIT registry stores this address and the generated IR calls // it by pointer. -inline void StoreI32(void* output, int32_t index, int32_t value) { - reinterpret_cast(output)[index] = value; -} +inline void StoreI32(void* output, int32_t index, int32_t value) { reinterpret_cast(output)[index] = value; } inline std::unique_ptr MakeRegistryWithStore() { auto r = MakeRegistry(); @@ -289,7 +288,6 @@ inline std::unique_ptr CompileOrDie(std::unique_ptr node, return engine; } -} // namespace bench -} // namespace jitfusion +} // namespace jitfusion::bench #endif // JITFUSION_BENCHMARK_BENCH_COMMON_H_ diff --git a/benchmark/bench_compile.cc b/benchmark/bench_compile.cc index 51fd519..a1a791a 100644 --- a/benchmark/bench_compile.cc +++ b/benchmark/bench_compile.cc @@ -30,18 +30,18 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeDeepNestedIf; -using ::jitfusion::bench::MakeLinearAddChain; -using ::jitfusion::bench::MakeListSumExpr; -using ::jitfusion::bench::MakeManyAbsCalls; -using ::jitfusion::bench::MakeRegistry; +using ::jitfusion::BatchExecEngine; using ::jitfusion::BinaryOPNode; using ::jitfusion::BinaryOPType; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecEngine; using ::jitfusion::ExecEngineOption; using ::jitfusion::ExecNode; +using ::jitfusion::bench::MakeDeepNestedIf; +using ::jitfusion::bench::MakeLinearAddChain; +using ::jitfusion::bench::MakeListSumExpr; +using ::jitfusion::bench::MakeManyAbsCalls; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // A. Compile @@ -139,8 +139,8 @@ void BM_BatchCompile(benchmark::State& state) { for (int i = 0; i < n; ++i) { nodes.emplace_back(MakeLinearAddChain(8)); } - ExecEngine engine; - auto st = engine.BatchCompile(nodes, reg); + BatchExecEngine engine; + auto st = engine.Compile(nodes, reg); benchmark::DoNotOptimize(st); if (!st.ok()) { state.SkipWithError("batch compile failed"); diff --git a/benchmark/bench_native_base.cc b/benchmark/bench_native_base.cc index 4853895..dc2c342 100644 --- a/benchmark/bench_native_base.cc +++ b/benchmark/bench_native_base.cc @@ -15,14 +15,14 @@ namespace { +using ::jitfusion::BatchExecEngine; +using ::jitfusion::ExecContext; +using ::jitfusion::ExecNode; +using ::jitfusion::RetType; using ::jitfusion::bench::CompileOrDie; using ::jitfusion::bench::MakeLinearAddChain; using ::jitfusion::bench::MakeListUnaryCall; using ::jitfusion::bench::MakeRegistry; -using ::jitfusion::ExecContext; -using ::jitfusion::ExecEngine; -using ::jitfusion::ExecNode; -using ::jitfusion::RetType; // ============================================================================= // D. ExecContext reuse — arena allocator cost @@ -119,8 +119,8 @@ void BM_BatchExecute_All(benchmark::State& state) { for (int i = 0; i < n; ++i) { nodes.emplace_back(MakeLinearAddChain(8)); } - ExecEngine engine; - auto cs = engine.BatchCompile(nodes, reg); + BatchExecEngine engine; + auto cs = engine.Compile(nodes, reg); if (!cs.ok()) { state.SkipWithError("batch compile failed"); return; @@ -147,8 +147,8 @@ void BM_BatchExecute_AtLoop(benchmark::State& state) { for (int i = 0; i < n; ++i) { nodes.emplace_back(MakeLinearAddChain(8)); } - ExecEngine engine; - auto cs = engine.BatchCompile(nodes, reg); + BatchExecEngine engine; + auto cs = engine.Compile(nodes, reg); if (!cs.ok()) { state.SkipWithError("batch compile failed"); return; diff --git a/include/batch_exec_engine.h b/include/batch_exec_engine.h new file mode 100644 index 0000000..a7031e6 --- /dev/null +++ b/include/batch_exec_engine.h @@ -0,0 +1,117 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 18:00:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 18:00:00 + */ +#pragma once + +#include +#include +#include +#include +#include +#include "exec_node.h" +#include "exec_options.h" +#include "function_registry.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +class JitCore; // private, defined in src/jit_core.h + +// Batch-oriented counterpart of ExecEngine. +// +// Use this class when you want to compile several independent expressions +// into a single JIT module so they can share a single set of optimization +// passes, memory pages, and entry-argument layout. Each compiled +// expression keeps its own return type and is addressed by index. +// +// Picking between ExecEngine and BatchExecEngine: +// +// * ExecEngine — one expression per JIT. Simplest; prefer this +// when you do not have N >= 2 related expressions. +// * BatchExecEngine — N >= 1 expressions share one JIT. Slightly +// lower per-call overhead once N is large and +// lets ORC share .rodata constants across entries. +// +// Thread-safety (mirrors ExecEngine): +// - Compile() is NOT thread-safe. +// - After a successful Compile(), the ExecuteAt / ExecuteAll overloads +// are safe to invoke concurrently across threads as long as each +// thread uses its own ExecContext. +// - A single ExecContext must never be shared across threads. +class BatchExecEngine { + public: + explicit BatchExecEngine(ExecEngineOption option = {}); + ~BatchExecEngine(); + BatchExecEngine(const BatchExecEngine&) = delete; + BatchExecEngine& operator=(const BatchExecEngine&) = delete; + + // --- Compile ------------------------------------------------------------- + // + // Compile N >= 1 expression roots into N entry functions sharing one + // JIT module. Each root may have its own return type; query the i-th + // return type via GetReturnType(i). + Status Compile(const std::vector>& exec_nodes, + const std::unique_ptr& func_registry); + + // --- Execute (index) ----------------------------------------------------- + // + // Execute the i-th compiled entry. The RetType* overloads box the + // result into the std::variant RetType and are the common case. + // The void* overloads are for entries whose root is a NoOPNode and + // that write results through an OutputNode + store function instead. + Status ExecuteAt(size_t index, void* entry_arguments, RetType* result); + Status ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, RetType* result); + Status ExecuteAt(size_t index, void* entry_arguments, void* result); + Status ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, void* result); + + // --- Execute (all) ------------------------------------------------------- + // + // Convenience: run every compiled entry in order and collect results. + // `results` is resized to the function count. + Status ExecuteAll(void* entry_arguments, std::vector* results); + Status ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, std::vector* results); + // For void-returning entries only (root = NoOPNode). `results` is passed + // through to the user store functions; its interpretation is up to the + // caller. + Status ExecuteAll(void* entry_arguments, void* results); + Status ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, void* results); + + // --- Introspection ------------------------------------------------------- + [[nodiscard]] size_t GetFunctionCount() const { return entry_func_ptrs_.size(); } + [[nodiscard]] ValueType GetReturnType(size_t index) const { return ret_types_[index]; } + [[nodiscard]] std::string_view GetIRCode() const; + + // --- Persistence --------------------------------------------------------- + // + // SaveCompiled packs the JIT-produced relocatable object bytes plus a + // small header (target triple, LLVM version, FP mode, per-entry return + // types, ...) into a self-contained byte string. LoadCompiled is an + // alternative entry point to Compile that accepts such a blob plus a + // FunctionRegistry. + // + // Compatibility contract (same as ExecEngine): + // * LLVM version / target triple / CPU must match exactly. + // * FunctionRegistry must re-register every C function the saved + // expression depends on under the same FunctionSignature. + // * GetIRCode() is empty after LoadCompiled — IR is never rebuilt. + // + // SaveCompiled requires ExecEngineOption::enable_save_compiled=true at + // the time of the original Compile(); otherwise no object bytes are + // captured and SaveCompiled returns an error. Blobs saved here can + // ONLY be loaded by BatchExecEngine::LoadCompiled — loading a batch + // blob into ExecEngine (or vice versa) fails cleanly with a mode + // mismatch message. + Status SaveCompiled(std::string* out) const; + Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry); + + private: + std::unique_ptr core_; + std::vector entry_func_ptrs_; + std::vector ret_types_; +}; + +} // namespace jitfusion diff --git a/include/exec_engine.h b/include/exec_engine.h index e3eb905..6271db5 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -2,125 +2,37 @@ * @Author: victorika * @Date: 2025-01-15 10:48:46 * @Last Modified by: victorika - * @Last Modified time: 2026-05-07 16:08:44 + * @Last Modified time: 2026-05-07 18:30:00 */ #pragma once -#include #include #include #include -#include -#include "arena.h" #include "exec_node.h" +#include "exec_options.h" #include "function_registry.h" -#include "llvm/ExecutionEngine/Orc/LLJIT.h" #include "status.h" #include "type.h" namespace jitfusion { -// Per-call mutable state used during Execute*. -// An ExecContext holds a memory arena (for values whose lifetime equals one -// execution) and an error list (populated by user-supplied C functions via -// AddError()). It is NOT thread-safe: a single ExecContext must never be shared -// across threads. For parallel execution, give each worker thread its own -// ExecContext; a single ExecEngine can be shared by all of them after Compile(). -// Within one thread, reusing an ExecContext across calls (via the -// `Execute(ExecContext&, ...)` overloads) avoids re-allocating the arena on -// each call. The engine resets the arena and clears the error list at the end -// of every Execute(ExecContext&, ...) call, so callers do NOT need to invoke -// Clear() manually between calls. As a consequence, any pointer returned -// through the arena (list / string payloads embedded in the previous result) -// becomes invalid as soon as the next Execute call returns — copy out anything -// you need to keep before issuing the next call. -struct ExecContext { - explicit ExecContext(int64_t alloc_min_chunk_size) : arena(alloc_min_chunk_size) {} - Arena arena; - std::vector errors; +class JitCore; // private, defined in src/jit_core.h - void Clear() { - arena.Reset(); - errors.clear(); - } - - [[nodiscard]] bool HasErrors() const { return !errors.empty(); } - - [[nodiscard]] std::string GetErrorMessage() const { - std::string msg; - for (size_t i = 0; i < errors.size(); ++i) { - if (i > 0) { - msg += "; "; - } - msg += errors[i]; - } - return msg; - } - - void AddError(std::string msg) { errors.emplace_back(std::move(msg)); } -}; - -// Floating-point semantics to request from the JIT code generator. +// ExecEngine compiles and runs a single expression. // -// kStrict -// IEEE-754 conformant: NaN / +-Inf / signed zero / rounding mode are all -// preserved. No fused multiply-add reassociation, no algebraic rewrites -// that could change bit-for-bit results. Pick this for finance / risk / -// anything where reproducibility across machines & LLVM versions matters. +// For multiple related expressions sharing one JIT module, use +// BatchExecEngine (include/batch_exec_engine.h) instead. // -// kFast -// Equivalent to enabling `-ffast-math` globally: -// * fused multiply-add (AllowFPOpFusion = Fast) -// * unsafe algebraic transforms (UnsafeFPMath = true), which implies -// NaN / Inf / signed-zero may be ignored and reassociation is allowed. -// Typically 1.3x - 2x faster on FP-heavy list kernels, but results can -// differ slightly from strict IEEE. Pick this for analytics / ML / search -// ranking where throughput dominates. -// -// The default is kFast for backwards compatibility with releases prior to -// the introduction of this switch. -enum class FPMathMode : std::uint8_t { - kStrict, - kFast, -}; - -struct ExecEngineOption { - int64_t exec_ctx_arena_alloc_min_chunk_size{4096}; - // If true, the fully optimized LLVM IR text will be captured during Compile and made available via GetIRCode(). - // Mainly for debugging: serializing a large Module to text is expensive (can be hundreds of KB and requires a - // full Module walk), so it is disabled by default in production. - bool dump_ir{false}; - // See FPMathMode above. Default stays kFast so that existing users' - // observed numeric behavior does not change when they upgrade. - FPMathMode fp_math_mode{FPMathMode::kFast}; - // If true, the raw compiled object bytes are captured during - // Compile() / BatchCompile() and retained in the engine so that - // SaveCompiled() can serialize them afterwards. Defaults to false - // because capturing costs one memcpy and ~KBs-to-MBs of extra - // resident memory per engine — pure waste for users who never - // persist compiled artifacts. - // - // Note on lifecycle: the captured bytes are released by the next - // Compile()/BatchCompile() (via ResetCompiledState) or when the - // engine is destroyed. There is deliberately no "release now" API: - // SaveCompiled may legitimately be called multiple times, so the - // engine keeps the bytes as long as the compilation is live. - // - // Must be set before Compile()/BatchCompile(); flipping it after - // the fact does NOT retroactively materialize bytes for an already- - // compiled engine — you would need to re-Compile(). - bool enable_save_compiled{false}; -}; - // Thread-safety contract: -// - Compile() / BatchCompile() are NOT thread-safe and must not run concurrently -// with any other method on the same ExecEngine instance. They mutate the -// engine's internal JIT state, const-value arena and function-pointer table. -// - After a successful Compile() / BatchCompile(), the Execute* / ExecuteAt* / -// ExecuteAll* overloads are safe to invoke concurrently from multiple threads -// on the same ExecEngine, provided each thread uses its own ExecContext. -// During execution the engine itself is only read; all per-call mutable state -// (arena, error list, intermediate allocations) lives inside ExecContext. +// - Compile() is NOT thread-safe and must not run concurrently with any other +// method on the same ExecEngine instance. It mutates the engine's internal +// JIT state, const-value arena and function-pointer table. +// - After a successful Compile(), the Execute* overloads are safe to invoke +// concurrently from multiple threads on the same ExecEngine, provided each +// thread uses its own ExecContext. During execution the engine itself is +// only read; all per-call mutable state (arena, error list, intermediate +// allocations) lives inside ExecContext. // - Overloads that do not take an explicit ExecContext internally construct a // fresh one on every call. They are thread-safe but pay per-call allocation // cost; prefer the ExecContext& overloads on hot paths so the arena can be @@ -130,108 +42,57 @@ struct ExecEngineOption { class ExecEngine { public: explicit ExecEngine(ExecEngineOption option = {}); - ~ExecEngine() = default; + ~ExecEngine(); ExecEngine(const ExecEngine&) = delete; ExecEngine& operator=(const ExecEngine&) = delete; + // --- Compile ------------------------------------------------------------- Status Compile(const std::unique_ptr& exec_node, const std::unique_ptr& func_registry); - // Applicable to scenarios with similar expressions, a result is returned through the root node. - // If you need to optimize the memory allocation issue of ExecContext, you can use the function passed to ExecContext. + // --- Execute ------------------------------------------------------------- + // + // RetType* overloads: box the result into the std::variant RetType. + // void* overloads: for entries whose root is a NoOPNode; data is + // written by the user store function rather than + // returned. `result` is forwarded to that store. Status Execute(void* entry_arguments, RetType* result); Status Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result); - - // Applicable to more complex scenarios, users need to use an output node and a custom store function to write data, - // and it will not return data from the root node. and root node must be the NoOpNode. - // If you need to optimize the memory allocation issue of ExecContext, you can use the function passed to ExecContext. Status Execute(void* entry_arguments, void* result); Status Execute(ExecContext& exec_ctx, void* entry_arguments, void* result); - // Batch compile multiple ASTs into separate functions within a single module. - // Each ExecNode can have any return type. All functions share the same JIT and memory pages. - Status BatchCompile(const std::vector>& exec_nodes, - const std::unique_ptr& func_registry); - // Execute a specific batch-compiled function by index. - // For void return type functions (NoOPNode root), use the void* result overload. - Status ExecuteAt(size_t index, void* entry_arguments, RetType* result); - Status ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, RetType* result); - // For void return type functions only. - Status ExecuteAt(size_t index, void* entry_arguments, void* result); - Status ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, void* result); - // Execute all batch-compiled functions. - Status ExecuteAll(void* entry_arguments, std::vector* results); - Status ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, std::vector* results); - // For void return type functions only. - Status ExecuteAll(void* entry_arguments, void* results); - Status ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, void* results); - - [[nodiscard]] size_t GetBatchFunctionCount() const { return batch_entry_func_ptrs_.size(); } - [[nodiscard]] ValueType GetBatchFunctionReturnType(size_t index) const { return batch_ret_types_[index]; } + // --- Introspection ------------------------------------------------------- + [[nodiscard]] std::string_view GetIRCode() const; - [[nodiscard]] std::string_view GetIRCode() const { return ir_code_; } - - // ------------------------------------------------------------------------- - // Compiled-artifact persistence (serialize / deserialize). - // - // After a successful Compile() / BatchCompile(), SaveCompiled() packs the - // JIT-produced relocatable object file plus a small header (engine mode, - // return type(s), target triple, LLVM version, FP mode, ...) into a - // self-contained byte string. LoadCompiled() is an alternative entry point - // to Compile() that takes such a byte string and a FunctionRegistry and - // restores the engine into a state indistinguishable from a fresh Compile() - // — i.e. all Execute* overloads work identically afterwards. + // --- Persistence --------------------------------------------------------- // - // This pair exists so that callers who already have a way to persist bytes - // (disk, KV store, network cache) can skip the most expensive parts of - // Compile(): IR construction, the O3 pipeline, and backend codegen. A - // successful LoadCompiled typically runs in single-digit milliseconds - // where Compile() takes tens to hundreds. + // SaveCompiled / LoadCompiled: persist a relocatable object-file blob + // plus a small header (engine mode, return type, target triple, LLVM + // version, FP mode, ...) so callers can skip the expensive O3 pipeline + // on subsequent runs. // // Compatibility contract: - // * A blob saved with one LLVM version / target / CPU can ONLY be loaded - // by a process with the matching LLVM version / target / CPU. Mismatches - // are detected and rejected cleanly (Status::InvalidArgument) rather - // than miscompiled silently. - // * The FunctionRegistry passed to LoadCompiled must register every C - // function referenced by the original ExecNode tree under the same - // FunctionSignature. Addresses may differ across processes (that's the - // whole point of relocatable globals), but names + param/ret types - // must match. Missing symbols surface as lookup failures on first - // Execute*. - // * IR dump (GetIRCode()) is NOT populated after LoadCompiled, because - // the IR is never constructed. This is intentional — getting the IR - // back would require re-running codegen, defeating the purpose. + // * LLVM version / target triple / CPU must match exactly. + // * The FunctionRegistry passed to LoadCompiled must re-register + // every C function referenced by the original expression under + // the same FunctionSignature; addresses may differ across + // processes (the whole point of relocatable globals), but + // names + param/ret types must match. + // * GetIRCode() is NOT populated after LoadCompiled — IR is never + // rebuilt. This is intentional. // - // SaveCompiled() is only valid immediately after a successful Compile() / - // BatchCompile() that ran with ExecEngineOption::enable_save_compiled=true. - // It will also fail on a default-constructed or load-restored engine, - // because in those cases the engine never captured object bytes to begin - // with. The opt-in is deliberate: capturing costs one memcpy of the .o - // file (a few KB to a few MB depending on pipeline size), plus the same - // again in resident memory until the engine is destroyed or re-compiled, - // which is pure overhead for users who never persist artifacts. + // SaveCompiled requires ExecEngineOption::enable_save_compiled=true at + // the time of Compile(); otherwise no object bytes are captured and + // SaveCompiled returns an error. Blobs saved by ExecEngine can ONLY + // be loaded by ExecEngine::LoadCompiled — loading a batch blob into + // ExecEngine (or vice versa) fails cleanly with a mode mismatch + // message. Status SaveCompiled(std::string* out) const; Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry); private: - Status CreateJitAndOptimize(const std::unique_ptr& func_registry, - std::unique_ptr owner, std::unique_ptr llvm_context); - - void ResetCompiledState(); - - std::unique_ptr jit_; - char* entry_func_ptr_; - ValueType ret_type_; - ExecEngineOption option_; - std::string ir_code_; - std::vector batch_entry_func_ptrs_; - std::vector batch_ret_types_; - // Raw object bytes captured during Compile/BatchCompile. Non-empty only - // when the engine produced them itself (we need the bytes to implement - // SaveCompiled). Filled in by a hook installed on the IRCompileLayer in - // CreateJitAndOptimize. - // - std::string compiled_object_bytes_; + std::unique_ptr core_; + char* entry_func_ptr_{nullptr}; + ValueType ret_type_{ValueType::kUnknown}; }; -} // namespace jitfusion \ No newline at end of file +} // namespace jitfusion diff --git a/include/exec_options.h b/include/exec_options.h new file mode 100644 index 0000000..9bc1864 --- /dev/null +++ b/include/exec_options.h @@ -0,0 +1,133 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 18:30:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 18:30:00 + */ +/* + * Public configuration / runtime-context types shared by ExecEngine + * and BatchExecEngine. + * + * Why these live in their own header (rather than inside exec_engine.h): + * * `ExecContext` is per-call mutable state; users construct one (or + * N — one per worker) and pass it to either engine class. + * * `ExecEngineOption` and `FPMathMode` parameterize compile-time + * behavior of either engine class. + * They are fundamentally orthogonal to "single vs batch", so giving + * them an independent home keeps each engine header focused on its + * own class definition. This file is also small and LLVM-free, so it + * is cheap for non-engine TUs (e.g. the serialization layer) to depend + * on directly. + */ + +#pragma once + +#include +#include +#include +#include "arena.h" + +namespace jitfusion { + +// Per-call mutable state used during Execute*. +// An ExecContext holds a memory arena (for values whose lifetime equals one +// execution) and an error list (populated by user-supplied C functions via +// AddError()). It is NOT thread-safe: a single ExecContext must never be +// shared across threads. For parallel execution, give each worker thread +// its own ExecContext; a single ExecEngine / BatchExecEngine can be shared +// by all of them after Compile(). +// Within one thread, reusing an ExecContext across calls (via the +// `Execute(ExecContext&, ...)` overloads) avoids re-allocating the arena on +// each call. The engine resets the arena and clears the error list at the +// end of every Execute(ExecContext&, ...) call, so callers do NOT need to +// invoke Clear() manually between calls. As a consequence, any pointer +// returned through the arena (list / string payloads embedded in the +// previous result) becomes invalid as soon as the next Execute call +// returns — copy out anything you need to keep before issuing the next +// call. +struct ExecContext { + explicit ExecContext(int64_t alloc_min_chunk_size) : arena(alloc_min_chunk_size) {} + Arena arena; + std::vector errors; + + void Clear() { + arena.Reset(); + errors.clear(); + } + + [[nodiscard]] bool HasErrors() const { return !errors.empty(); } + + [[nodiscard]] std::string GetErrorMessage() const { + std::string msg; + for (size_t i = 0; i < errors.size(); ++i) { + if (i > 0) { + msg += "; "; + } + msg += errors[i]; + } + return msg; + } + + void AddError(std::string msg) { errors.emplace_back(std::move(msg)); } +}; + +// Floating-point semantics to request from the JIT code generator. +// +// kStrict +// IEEE-754 conformant: NaN / +-Inf / signed zero / rounding mode are all +// preserved. No fused multiply-add reassociation, no algebraic rewrites +// that could change bit-for-bit results. Pick this for finance / risk / +// anything where reproducibility across machines & LLVM versions matters. +// +// kFast +// Equivalent to enabling `-ffast-math` globally: +// * fused multiply-add (AllowFPOpFusion = Fast) +// * unsafe algebraic transforms (UnsafeFPMath = true), which implies +// NaN / Inf / signed-zero may be ignored and reassociation is allowed. +// Typically 1.3x - 2x faster on FP-heavy list kernels, but results can +// differ slightly from strict IEEE. Pick this for analytics / ML / search +// ranking where throughput dominates. +// +// The default is kFast for backwards compatibility with releases prior to +// the introduction of this switch. +// +// On-wire stability: kStrict and kFast are pinned to numeric values 0 and +// 1 respectively. The serialization format (compiled_artifact) writes +// the enum value as a single byte; reordering or renumbering members +// would silently break previously-saved artifacts. A static_assert pair +// in compiled_artifact.cc guards this. +enum class FPMathMode : std::uint8_t { + kStrict = 0, + kFast = 1, +}; + +struct ExecEngineOption { + int64_t exec_ctx_arena_alloc_min_chunk_size{4096}; + // If true, the fully optimized LLVM IR text will be captured during + // Compile and made available via GetIRCode(). Mainly for debugging: + // serializing a large Module to text is expensive (can be hundreds of + // KB and requires a full Module walk), so it is disabled by default in + // production. + bool dump_ir{false}; + // See FPMathMode above. Default stays kFast so that existing users' + // observed numeric behavior does not change when they upgrade. + FPMathMode fp_math_mode{FPMathMode::kFast}; + // If true, the raw compiled object bytes are captured during + // Compile() and retained in the engine so that SaveCompiled() can + // serialize them afterwards. Defaults to false because capturing + // costs one memcpy and ~KBs-to-MBs of extra resident memory per + // engine — pure waste for users who never persist compiled artifacts. + // + // Note on lifecycle: the captured bytes are released by the next + // Compile() or when the engine is destroyed. There is deliberately + // no "release now" API: SaveCompiled may legitimately be called + // multiple times, so the engine keeps the bytes as long as the + // compilation is live. + // + // Must be set before Compile(); flipping it after the fact does NOT + // retroactively materialize bytes for an already-compiled engine — + // you would need to re-Compile(). + bool enable_save_compiled{false}; +}; + +} // namespace jitfusion diff --git a/src/batch_exec_engine.cc b/src/batch_exec_engine.cc new file mode 100644 index 0000000..6fd0f4b --- /dev/null +++ b/src/batch_exec_engine.cc @@ -0,0 +1,252 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 18:00:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 18:00:00 + */ +#include "batch_exec_engine.h" + +#include +#include +#include +#include +#include +#include +#include "compiled_artifact.h" +#include "exec_node.h" +#include "execute_dispatch.h" +#include "function_registry.h" +#include "jit_core.h" +#include "llvm/Config/llvm-config.h" +#include "llvm/TargetParser/Host.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +BatchExecEngine::BatchExecEngine(ExecEngineOption option) : core_(std::make_unique(option)) {} +BatchExecEngine::~BatchExecEngine() = default; + +std::string_view BatchExecEngine::GetIRCode() const { return core_->GetIRCode(); } + +Status BatchExecEngine::Compile(const std::vector>& exec_nodes, + const std::unique_ptr& func_registry) { + if (exec_nodes.empty()) { + return Status::ParseError("Compile: exec_nodes is empty"); + } + entry_func_ptrs_.clear(); + ret_types_.clear(); + + std::vector nodes; + nodes.reserve(exec_nodes.size()); + std::vector names; + names.reserve(exec_nodes.size()); + for (size_t i = 0; i < exec_nodes.size(); ++i) { + nodes.emplace_back(exec_nodes[i].get()); + names.emplace_back(kEntryFunctionName + std::to_string(i)); + } + return core_->BuildAndLink(nodes, names, func_registry, &entry_func_ptrs_, &ret_types_); +} + +Status BatchExecEngine::ExecuteAt(size_t index, void* entry_arguments, RetType* result) { + if (index >= entry_func_ptrs_.size()) { + return Status::RuntimeError("ExecuteAt: index out of range"); + } + ExecContext exec_ctx(core_->GetOption().exec_ctx_arena_alloc_min_chunk_size); + char* func_ptr = entry_func_ptrs_[index]; + ValueType ret_type = ret_types_[index]; + JF_EXPAND_SWITCH_TYPE(func_ptr, ret_type) + if (exec_ctx.HasErrors()) { + return Status::RuntimeError(exec_ctx.GetErrorMessage()); + } + return Status::OK(); +} + +Status BatchExecEngine::ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, RetType* result) { + if (index >= entry_func_ptrs_.size()) { + return Status::RuntimeError("ExecuteAt: index out of range"); + } + char* func_ptr = entry_func_ptrs_[index]; + ValueType ret_type = ret_types_[index]; + JF_EXPAND_SWITCH_TYPE(func_ptr, ret_type) + Status ret = Status::OK(); + if (exec_ctx.HasErrors()) { + ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); + } + exec_ctx.Clear(); + return ret; +} + +Status BatchExecEngine::ExecuteAt(size_t index, void* entry_arguments, void* result) { + if (index >= entry_func_ptrs_.size()) { + return Status::RuntimeError("ExecuteAt: index out of range"); + } + ExecContext exec_ctx(core_->GetOption().exec_ctx_arena_alloc_min_chunk_size); + reinterpret_cast<::jitfusion::execute_dispatch::return_void_function_type>(entry_func_ptrs_[index])( + entry_arguments, &exec_ctx, result); + if (exec_ctx.HasErrors()) { + return Status::RuntimeError(exec_ctx.GetErrorMessage()); + } + return Status::OK(); +} + +Status BatchExecEngine::ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, void* result) { + if (index >= entry_func_ptrs_.size()) { + return Status::RuntimeError("ExecuteAt: index out of range"); + } + reinterpret_cast<::jitfusion::execute_dispatch::return_void_function_type>(entry_func_ptrs_[index])( + entry_arguments, &exec_ctx, result); + Status ret = Status::OK(); + if (exec_ctx.HasErrors()) { + ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); + } + exec_ctx.Clear(); + return ret; +} + +Status BatchExecEngine::ExecuteAll(void* entry_arguments, std::vector* results) { + results->resize(entry_func_ptrs_.size()); + std::string all_errors; + for (size_t i = 0; i < entry_func_ptrs_.size(); ++i) { + Status st = ExecuteAt(i, entry_arguments, &(*results)[i]); + if (!st.ok()) { + if (!all_errors.empty()) { + all_errors += "| "; + } + all_errors += st.ToString(); + } + } + if (!all_errors.empty()) { + return Status::RuntimeError(all_errors); + } + return Status::OK(); +} + +Status BatchExecEngine::ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, std::vector* results) { + results->resize(entry_func_ptrs_.size()); + std::string all_errors; + for (size_t i = 0; i < entry_func_ptrs_.size(); ++i) { + Status st = ExecuteAt(i, exec_ctx, entry_arguments, &(*results)[i]); + if (!st.ok()) { + if (!all_errors.empty()) { + all_errors += "| "; + } + all_errors += st.ToString(); + } + } + if (!all_errors.empty()) { + return Status::RuntimeError(all_errors); + } + return Status::OK(); +} + +Status BatchExecEngine::ExecuteAll(void* entry_arguments, void* results) { + std::string all_errors; + for (size_t i = 0; i < entry_func_ptrs_.size(); ++i) { + Status st = ExecuteAt(i, entry_arguments, results); + if (!st.ok()) { + if (!all_errors.empty()) { + all_errors += "| "; + } + all_errors += st.ToString(); + } + } + if (!all_errors.empty()) { + return Status::RuntimeError(all_errors); + } + return Status::OK(); +} + +Status BatchExecEngine::ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, void* results) { + std::string all_errors; + for (size_t i = 0; i < entry_func_ptrs_.size(); ++i) { + Status st = ExecuteAt(i, exec_ctx, entry_arguments, results); + if (!st.ok()) { + if (!all_errors.empty()) { + all_errors += "| "; + } + all_errors += st.ToString(); + } + } + if (!all_errors.empty()) { + return Status::RuntimeError(all_errors); + } + return Status::OK(); +} + +Status BatchExecEngine::SaveCompiled(std::string* out) const { + if (out == nullptr) { + return Status::InvalidArgument("SaveCompiled: out must not be null"); + } + if (entry_func_ptrs_.empty()) { + return Status::RuntimeError("SaveCompiled: nothing compiled yet. Call Compile() first."); + } + const std::string_view obj = core_->GetCompiledObjectBytes(); + if (obj.empty()) { + return Status::RuntimeError( + "SaveCompiled: no object bytes captured. Set " + "ExecEngineOption::enable_save_compiled=true BEFORE calling Compile(), " + "then re-compile. (Artifacts loaded via LoadCompiled also cannot be " + "re-saved — the loaded bytes are intentionally not retained.)"); + } + + const ExecEngineOption& option = core_->GetOption(); + ArtifactHeader header; + header.llvm_version = LLVM_VERSION_STRING; + header.target_triple = llvm::sys::getProcessTriple(); + header.cpu_name = llvm::sys::getHostCPUName().str(); + header.mode = ArtifactMode::kBatch; + header.fp_math_mode = option.fp_math_mode; + header.per_entry_ret_types = ret_types_; + return SerializeArtifact(header, obj, out); +} + +Status BatchExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry) { + ArtifactHeader header; + std::string_view obj_view; + JF_RETURN_NOT_OK(DeserializeArtifact(bytes, &header, &obj_view)); + + if (header.llvm_version != LLVM_VERSION_STRING) { + return Status::InvalidArgument( + "compiled artifact: LLVM version mismatch (artifact=", header.llvm_version, ", runtime=", LLVM_VERSION_STRING, + "). LLVM does not guarantee object-file compatibility across versions; regenerate the artifact."); + } + { + const std::string current_triple = llvm::sys::getProcessTriple(); + if (header.target_triple != current_triple) { + return Status::InvalidArgument("compiled artifact: target triple mismatch (artifact=", header.target_triple, + ", runtime=", current_triple, ")"); + } + } + { + const std::string current_cpu = llvm::sys::getHostCPUName().str(); + if (header.cpu_name != current_cpu) { + return Status::InvalidArgument("compiled artifact: host CPU mismatch (artifact=", header.cpu_name, + ", runtime=", current_cpu, "). Regenerate the artifact on this host."); + } + } + if (header.mode != ArtifactMode::kBatch) { + return Status::InvalidArgument( + "compiled artifact: mode mismatch — this blob was saved by ExecEngine. " + "Load it with ExecEngine::LoadCompiled instead."); + } + + ExecEngineOption new_opt = core_->GetOption(); + new_opt.fp_math_mode = header.fp_math_mode; + core_ = std::make_unique(new_opt); + + const size_t n = header.per_entry_ret_types.size(); + std::vector symbol_names; + symbol_names.reserve(n); + for (size_t i = 0; i < n; ++i) { + symbol_names.emplace_back(kEntryFunctionName + std::to_string(i)); + } + std::vector func_ptrs; + JF_RETURN_NOT_OK(core_->LoadObject(obj_view, symbol_names, func_registry, &func_ptrs)); + + entry_func_ptrs_ = std::move(func_ptrs); + ret_types_ = std::move(header.per_entry_ret_types); + return Status::OK(); +} + +} // namespace jitfusion diff --git a/src/compiled_artifact.cc b/src/compiled_artifact.cc index 5de4544..f952d80 100644 --- a/src/compiled_artifact.cc +++ b/src/compiled_artifact.cc @@ -150,12 +150,11 @@ class ArtifactReader { std::size_t pos_{}; }; -// Pin the numeric values of ArtifactFPMathMode / ArtifactMode to the -// on-wire encoding. If someone later reorders these enums, the -// static_asserts catch it at compile time instead of at Load time on -// a user's machine. -static_assert(static_cast(ArtifactFPMathMode::kStrict) == 0, "FPMathMode::kStrict must serialize as 0"); -static_assert(static_cast(ArtifactFPMathMode::kFast) == 1, "FPMathMode::kFast must serialize as 1"); +// Pin the numeric values of FPMathMode / ArtifactMode to the on-wire +// encoding. If someone later reorders these enums, the static_asserts +// catch it at compile time instead of at Load time on a user's machine. +static_assert(static_cast(FPMathMode::kStrict) == 0, "FPMathMode::kStrict must serialize as 0"); +static_assert(static_cast(FPMathMode::kFast) == 1, "FPMathMode::kFast must serialize as 1"); static_assert(static_cast(ArtifactMode::kSingle) == 0, "ArtifactMode::kSingle must serialize as 0"); static_assert(static_cast(ArtifactMode::kBatch) == 1, "ArtifactMode::kBatch must serialize as 1"); @@ -185,7 +184,6 @@ Status SerializeArtifact(const ArtifactHeader& header, std::string_view object_b AppendLenPrefixedStr(*out, header.cpu_name); AppendU8(*out, static_cast(header.mode)); AppendU8(*out, static_cast(header.fp_math_mode)); - AppendU8(*out, static_cast(header.top_ret_type)); const auto num_entries = static_cast(header.per_entry_ret_types.size()); AppendU32LE(*out, num_entries); @@ -242,15 +240,11 @@ Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, st std::uint8_t fp_byte = 0; JF_RETURN_NOT_OK(r.ReadU8(&fp_byte)); - if (fp_byte != static_cast(ArtifactFPMathMode::kStrict) && - fp_byte != static_cast(ArtifactFPMathMode::kFast)) { + if (fp_byte != static_cast(FPMathMode::kStrict) && + fp_byte != static_cast(FPMathMode::kFast)) { return Status::InvalidArgument("compiled artifact: unknown fp_math_mode byte ", static_cast(fp_byte)); } - out_header->fp_math_mode = static_cast(fp_byte); - - std::uint8_t top_ret_type_byte = 0; - JF_RETURN_NOT_OK(r.ReadU8(&top_ret_type_byte)); - out_header->top_ret_type = static_cast(top_ret_type_byte); + out_header->fp_math_mode = static_cast(fp_byte); std::uint32_t num_entries = 0; JF_RETURN_NOT_OK(r.ReadU32LE(&num_entries)); @@ -266,14 +260,6 @@ Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, st JF_RETURN_NOT_OK(r.ReadU8(&rt_byte)); out_header->per_entry_ret_types[i] = static_cast(rt_byte); } - // Cross-check: the top-level ret_type duplicates per_entry[0] in - // single mode and exists purely as a defense-in-depth marker. - // A mismatch indicates a corrupted or hand-tampered blob. - if (out_header->mode == ArtifactMode::kSingle && out_header->top_ret_type != out_header->per_entry_ret_types[0]) { - return Status::InvalidArgument( - "compiled artifact: inconsistent ret_type (top=", static_cast(out_header->top_ret_type), - ", per-entry=", static_cast(out_header->per_entry_ret_types[0]), ")"); - } std::uint64_t obj_size = 0; JF_RETURN_NOT_OK(r.ReadU64LE(&obj_size)); diff --git a/src/compiled_artifact.h b/src/compiled_artifact.h index 475a74f..ec8aeb9 100644 --- a/src/compiled_artifact.h +++ b/src/compiled_artifact.h @@ -49,14 +49,12 @@ * cpu_name len-prefixed utf8 str (sys::getHostCPUName()) * mode uint8 (0 = single, 1 = batch) * fp_math_mode uint8 (FPMathMode enum value) - * top_ret_type uint8 (ValueType; meaningful in single mode, - * duplicates per_entry_ret_types[0]) * num_entries uint32 (>= 1) * per-entry repeated num_entries times: * ret_type uint8 (ValueType) * obj_size uint64 * obj_bytes raw bytes (the relocatable .o) - * extension_count uint32 (0 in v1) + * extension_count uint32 (0 in v2) * per-extension repeated extension_count times: * tag uint32 (ArtifactExtensionTag) * payload_len uint32 @@ -79,23 +77,18 @@ #include #include #include +#include "exec_options.h" // jitfusion::FPMathMode #include "status.h" #include "type.h" namespace jitfusion { -// Kept in sync with the FPMathMode in include/exec_engine.h. We do -// NOT include exec_engine.h here because that file pulls in LLVM — -// which would defeat the "pure serde, fast to compile" goal of this -// TU. Duplicating a 2-value enum is a fine tradeoff. -// -// Callers at the ExecEngine boundary are responsible for converting -// between FPMathMode and ArtifactFPMathMode. A static_assert pair in -// compiled_artifact.cc pins the numeric values to match. -enum class ArtifactFPMathMode : std::uint8_t { - kStrict = 0, - kFast = 1, -}; +// The on-wire FP math mode IS the public FPMathMode enum. They used to +// be two separate types to avoid pulling LLVM into this serde TU, but +// the public headers no longer include LLVM, so the split is obsolete. +// FPMathMode's underlying type and enumerator values are pinned to the +// on-wire layout; a static_assert pair in compiled_artifact.cc guards +// this. enum class ArtifactMode : std::uint8_t { kSingle = 0, @@ -114,7 +107,7 @@ enum class ArtifactMode : std::uint8_t { // an old reader MUST notice (e.g. object bytes got compressed) // is not an extension; bump kArtifactFormatVersion instead. enum class ArtifactExtensionTag : std::uint32_t { - // No tags defined in v1. + // No tags defined in v2. // kExampleMetadata = 1, // payload: }; @@ -134,11 +127,11 @@ struct ArtifactHeader { std::string target_triple; std::string cpu_name; ArtifactMode mode{ArtifactMode::kSingle}; - ArtifactFPMathMode fp_math_mode{ArtifactFPMathMode::kFast}; - ValueType top_ret_type{ValueType::kUnknown}; + FPMathMode fp_math_mode{FPMathMode::kFast}; // Per-entry return types; size doubles as the "num_entries" field - // on the wire. Entry symbol names are intentionally NOT stored — - // see the "Notable non-field" comment in the file header. + // on the wire (always >= 1). Entry symbol names are intentionally + // NOT stored — see the "Notable non-field" comment in the file + // header. In single mode per_entry_ret_types has size 1. std::vector per_entry_ret_types; // === Forward-compat extension area === @@ -149,7 +142,7 @@ struct ArtifactHeader { // change that breaks byte-level compatibility with existing readers. // Purely additive changes via the extension area do NOT require a // version bump. -constexpr std::uint32_t kArtifactFormatVersion = 1; +constexpr std::uint32_t kArtifactFormatVersion = 2; // Serialize `header` + `object_bytes` into a self-contained JFCA // blob. Appends to `*out` (does not clear), matching std::string's diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 13e7a12..ad965f7 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -2,409 +2,55 @@ * @Author: victorika * @Date: 2025-01-15 10:59:33 * @Last Modified by: victorika - * @Last Modified time: 2026-05-07 16:41:15 + * @Last Modified time: 2026-05-07 18:00:00 */ #include "exec_engine.h" + +#include #include #include +#include +#include #include -#include "codegen/codegen.h" #include "compiled_artifact.h" #include "exec_node.h" -#include "function/function_init.h" +#include "execute_dispatch.h" #include "function_registry.h" -#include "llvm/Analysis/TargetTransformInfo.h" +#include "jit_core.h" #include "llvm/Config/llvm-config.h" -#include "llvm/ExecutionEngine/ExecutionEngine.h" -#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h" -#include "llvm/IR/Intrinsics.h" -#include "llvm/IR/LegacyPassManager.h" -#include "llvm/IR/Value.h" -#include "llvm/IR/Verifier.h" -#include "llvm/MC/TargetRegistry.h" -#include "llvm/Passes/PassBuilder.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/CodeGen.h" -#include "llvm/Support/DynamicLibrary.h" -#include "llvm/Support/MemoryBuffer.h" -#include "llvm/Support/TargetSelect.h" -#include "llvm/Support/raw_ostream.h" -#include "llvm/Target/TargetMachine.h" #include "llvm/TargetParser/Host.h" -#include "llvm/Transforms/IPO/AlwaysInliner.h" -#include "llvm/Transforms/IPO/DeadArgumentElimination.h" -#include "llvm/Transforms/Scalar.h" -#include "llvm/Transforms/Scalar/CallSiteSplitting.h" -#include "llvm/Transforms/Scalar/DCE.h" -#include "llvm/Transforms/Scalar/EarlyCSE.h" -#include "llvm/Transforms/Scalar/GVN.h" -#include "llvm/Transforms/Scalar/MergedLoadStoreMotion.h" -#include "llvm/Transforms/Scalar/Reassociate.h" -#include "llvm/Transforms/Vectorize/LoopVectorize.h" -#include "llvm/Transforms/Vectorize/SLPVectorizer.h" #include "status.h" #include "type.h" -#include "validator.h" namespace jitfusion { -namespace { - -const std::string kEntryFunctionName = "entry"; - -struct LLVMInit { - LLVMInit() { - llvm::InitializeNativeTarget(); - llvm::InitializeNativeTargetAsmPrinter(); - llvm::InitializeNativeTargetAsmParser(); - llvm::InitializeNativeTargetDisassembler(); - llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr); - } -}; - -LLVMStructType CreateLLVMStructType(llvm::LLVMContext& context) { - LLVMStructType llvm_struct_type; - auto* ptr_ty = llvm::PointerType::getUnqual(context); - auto* i32_ty = llvm::Type::getInt32Ty(context); - llvm_struct_type.string_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "StringStruct"); - llvm_struct_type.u8list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U8ListStruct"); - llvm_struct_type.u16list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U16ListStruct"); - llvm_struct_type.u32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U32ListStruct"); - llvm_struct_type.u64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U64ListStruct"); - llvm_struct_type.i8list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I8ListStruct"); - llvm_struct_type.i16list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I16ListStruct"); - llvm_struct_type.i32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I32ListStruct"); - llvm_struct_type.i64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I64ListStruct"); - llvm_struct_type.f32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "F32ListStruct"); - llvm_struct_type.f64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "F64ListStruct"); - llvm_struct_type.stringlist_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "StringListStruct"); - return llvm_struct_type; -} - -Status GetEntryFunctionCallee(llvm::LLVMContext& context, std::unique_ptr& m, - const LLVMStructType& llvm_struct_type, const std::string& func_name, ValueType ret_type, - llvm::FunctionCallee* entry_func_callee) { - auto* ptr_ty = llvm::PointerType::getUnqual(context); - switch (ret_type) { - case ValueType::kVoid: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getVoidTy(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU8: - case ValueType::kI8: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt8Ty(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU16: - case ValueType::kI16: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt16Ty(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU32: - case ValueType::kI32: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt32Ty(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU64: - case ValueType::kI64: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt64Ty(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kF32: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getFloatTy(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kF64: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getDoubleTy(context), ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kString: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.string_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU8List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u8list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU16List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u16list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU32List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u32list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kU64List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u64list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kI8List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i8list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kI16List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i16list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kI32List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i32list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kI64List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i64list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kF32List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.f32list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kF64List: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.f64list_type, ptr_ty, ptr_ty, ptr_ty); - } break; - case ValueType::kStringList: { - *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.stringlist_type, ptr_ty, ptr_ty, ptr_ty); - } break; - default: - return Status::RuntimeError( - "[internal] unknown return type for entry function: ", TypeHelper::TypeToString(ret_type), " (compiler bug)"); - } - return Status::OK(); -} - -struct CommutativeCallCanonicalizerPass : public llvm::PassInfoMixin { - CommutativeCallCanonicalizerPass() = default; - - static llvm::PreservedAnalyses run(llvm::Function& f, llvm::FunctionAnalysisManager& /*AM*/) { - bool changed = false; - for (auto& bb : f) { - for (auto& i : bb) { - if (auto* ci = llvm::dyn_cast(&i)) { - llvm::Function* called_func = ci->getCalledFunction(); - if (called_func == nullptr) { - continue; - } - if (!called_func->hasFnAttribute(kCommutative)) { - continue; - } - if (ci->arg_size() < 2) { - continue; - } - llvm::Value* arg0 = ci->getArgOperand(0); - llvm::Value* arg1 = ci->getArgOperand(1); - if (arg0->getType() != arg1->getType()) { - continue; - } - if (ShouldSwapArguments(arg0, arg1)) { - ci->setArgOperand(0, arg1); - ci->setArgOperand(1, arg0); - changed = true; - } - } - } - } - return changed ? llvm::PreservedAnalyses::none() : llvm::PreservedAnalyses::all(); - } - - private: - static bool ShouldSwapArguments(llvm::Value* arg0, llvm::Value* arg1) { - return std::greater()(arg0, arg1); - } -}; - -Status BuildEntryFunction(llvm::LLVMContext& llvm_context, std::unique_ptr& owner, - const LLVMStructType& llvm_struct_type, const std::string& func_name, ValueType ret_type, - const std::unique_ptr& exec_node, - const std::unique_ptr& func_registry) { - llvm::FunctionCallee entry_func_callee; - JF_RETURN_NOT_OK( - GetEntryFunctionCallee(llvm_context, owner, llvm_struct_type, func_name, ret_type, &entry_func_callee)); - if (auto* entry_function = llvm::dyn_cast(entry_func_callee.getCallee())) { - entry_function->addAttributeAtIndex(1, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); - entry_function->addAttributeAtIndex(1, llvm::Attribute::get(llvm_context, llvm::Attribute::ReadOnly)); - entry_function->addAttributeAtIndex(2, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); - entry_function->addAttributeAtIndex(3, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); - } - - auto* entry_function = llvm::cast(entry_func_callee.getCallee()); - llvm::BasicBlock* entry_bb = llvm::BasicBlock::Create(llvm_context, "entryBB", entry_function); - llvm::IRBuilder<> builder(entry_bb); - std::unique_ptr codegen_ctx = std::make_unique( - llvm_context, *owner, builder, entry_function, llvm_struct_type, func_registry); - - CodeGen codegen(*codegen_ctx); - - llvm::Value* ret_value; - JF_RETURN_NOT_OK(codegen.GetValue(exec_node.get(), &ret_value)); - if (ValueType::kVoid == ret_type) { - builder.CreateRetVoid(); - } else { - builder.CreateRet(ret_value); - } - return Status::OK(); -} - -using return_void_function_type = void (*)(void*, void*, void*); -using return_u8_function_type = uint8_t (*)(void*, void*, void*); -using return_u16_function_type = uint16_t (*)(void*, void*, void*); -using return_u32_function_type = uint32_t (*)(void*, void*, void*); -using return_u64_function_type = uint64_t (*)(void*, void*, void*); -using return_i8_function_type = int8_t (*)(void*, void*, void*); -using return_i16_function_type = int16_t (*)(void*, void*, void*); -using return_i32_function_type = int32_t (*)(void*, void*, void*); -using return_i64_function_type = int64_t (*)(void*, void*, void*); -using return_f32_function_type = float (*)(void*, void*, void*); -using return_f64_function_type = double (*)(void*, void*, void*); -using return_string_function_type = StringStruct (*)(void*, void*, void*); -using return_u8list_function_type = U8ListStruct (*)(void*, void*, void*); -using return_u16list_function_type = U16ListStruct (*)(void*, void*, void*); -using return_u32list_function_type = U32ListStruct (*)(void*, void*, void*); -using return_u64list_function_type = U64ListStruct (*)(void*, void*, void*); -using return_i8list_function_type = I8ListStruct (*)(void*, void*, void*); -using return_i16list_function_type = I16ListStruct (*)(void*, void*, void*); -using return_i32list_function_type = I32ListStruct (*)(void*, void*, void*); -using return_i64list_function_type = I64ListStruct (*)(void*, void*, void*); -using return_f32list_function_type = F32ListStruct (*)(void*, void*, void*); -using return_f64list_function_type = F64ListStruct (*)(void*, void*, void*); -using return_stringlist_function_type = StringListStruct (*)(void*, void*, void*); - -} // namespace +ExecEngine::ExecEngine(ExecEngineOption option) : core_(std::make_unique(option)) {} +ExecEngine::~ExecEngine() = default; -ExecEngine::ExecEngine(ExecEngineOption option) : option_(option) {} - -void ExecEngine::ResetCompiledState() { - jit_.reset(); - batch_entry_func_ptrs_.clear(); - batch_ret_types_.clear(); - ir_code_.clear(); - compiled_object_bytes_.clear(); -} +std::string_view ExecEngine::GetIRCode() const { return core_->GetIRCode(); } Status ExecEngine::Compile(const std::unique_ptr& exec_node, const std::unique_ptr& func_registry) { - // validator - Validator validator(func_registry); - JF_RETURN_NOT_OK(validator.Validate(exec_node.get())); - ret_type_ = exec_node->GetReturnType(); - - ResetCompiledState(); - - // codegen - std::unique_ptr llvm_context = std::make_unique(); - std::unique_ptr owner = std::make_unique("module", *llvm_context); - - LLVMStructType llvm_struct_type = CreateLLVMStructType(*llvm_context); - JF_RETURN_NOT_OK(BuildEntryFunction(*llvm_context, owner, llvm_struct_type, kEntryFunctionName, ret_type_, exec_node, - func_registry)); - JF_RETURN_NOT_OK(func_registry->SetCFuncAttr(owner.get())); - - // verify - std::string error_info; - llvm::raw_string_ostream error_stream(error_info); - if (llvm::verifyModule(*owner, &error_stream)) { - return Status::RuntimeError("Module verification failed: ", error_info); - } - JF_RETURN_NOT_OK(CreateJitAndOptimize(func_registry, std::move(owner), std::move(llvm_context))); - auto entry_func_offset = jit_->lookup("entry"); - if (!entry_func_offset) { - return Status::RuntimeError("Failed to find entry function"); - } + // Clear previous compilation state up front so that a failed Compile + // leaves the engine in a cleanly-uncompiled state rather than a half- + // configured one. entry_func_ptr_ = nullptr; - entry_func_ptr_ += entry_func_offset->getValue(); + ret_type_ = ValueType::kUnknown; + std::vector nodes{exec_node.get()}; + std::vector names{kEntryFunctionName}; + std::vector func_ptrs; + std::vector ret_types; + JF_RETURN_NOT_OK(core_->BuildAndLink(nodes, names, func_registry, &func_ptrs, &ret_types)); + + entry_func_ptr_ = func_ptrs[0]; + ret_type_ = ret_types[0]; return Status::OK(); } -#define EXPAND_SWITCH_TYPE(func_ptr, ret_type) \ - switch (ret_type) { \ - case ValueType::kVoid: { \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kU8: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kI8: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kU16: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kI16: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kU32: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kI32: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kU64: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kI64: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kF32: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kF64: { \ - *result = reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - } break; \ - case ValueType::kString: { \ - StringStruct string = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - std::string res(string.data, string.len); \ - *result = std::move(res); \ - } break; \ - case ValueType::kU8List: { \ - U8ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kU16List: { \ - U16ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kU32List: { \ - U32ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kU64List: { \ - U64ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kI8List: { \ - I8ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kI16List: { \ - I16ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kI32List: { \ - I32ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kI64List: { \ - I64ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kF32List: { \ - F32ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kF64List: { \ - F64ListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - *result = std::vector(list.data, list.data + list.len); \ - } break; \ - case ValueType::kStringList: { \ - StringListStruct list = \ - reinterpret_cast(func_ptr)(entry_arguments, &exec_ctx, nullptr); \ - std::vector res; \ - res.reserve(list.len); \ - for (uint32_t i = 0; i < list.len; ++i) { \ - res.emplace_back(list.data[i].data, list.data[i].len); \ - } \ - *result = std::move(res); \ - } break; \ - default: \ - return Status::RuntimeError("Unsupported return type"); \ - } - Status ExecEngine::Execute(void* entry_arguments, RetType* result) { - ExecContext exec_ctx(option_.exec_ctx_arena_alloc_min_chunk_size); - EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) + ExecContext exec_ctx(core_->GetOption().exec_ctx_arena_alloc_min_chunk_size); + JF_EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) if (exec_ctx.HasErrors()) { return Status::RuntimeError(exec_ctx.GetErrorMessage()); } @@ -412,7 +58,7 @@ Status ExecEngine::Execute(void* entry_arguments, RetType* result) { } Status ExecEngine::Execute(ExecContext& exec_ctx, void* entry_arguments, RetType* result) { - EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) + JF_EXPAND_SWITCH_TYPE(entry_func_ptr_, ret_type_) Status ret = Status::OK(); if (exec_ctx.HasErrors()) { ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); @@ -422,8 +68,9 @@ Status ExecEngine::Execute(ExecContext& exec_ctx, void* entry_arguments, RetType } Status ExecEngine::Execute(void* entry_arguments, void* result) { - ExecContext exec_ctx(option_.exec_ctx_arena_alloc_min_chunk_size); - reinterpret_cast(entry_func_ptr_)(entry_arguments, &exec_ctx, result); + ExecContext exec_ctx(core_->GetOption().exec_ctx_arena_alloc_min_chunk_size); + reinterpret_cast<::jitfusion::execute_dispatch::return_void_function_type>(entry_func_ptr_)(entry_arguments, + &exec_ctx, result); if (exec_ctx.HasErrors()) { return Status::RuntimeError(exec_ctx.GetErrorMessage()); } @@ -431,7 +78,8 @@ Status ExecEngine::Execute(void* entry_arguments, void* result) { } Status ExecEngine::Execute(ExecContext& exec_ctx, void* entry_arguments, void* result) { - reinterpret_cast(entry_func_ptr_)(entry_arguments, &exec_ctx, result); + reinterpret_cast<::jitfusion::execute_dispatch::return_void_function_type>(entry_func_ptr_)(entry_arguments, + &exec_ctx, result); Status ret = Status::OK(); if (exec_ctx.HasErrors()) { ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); @@ -440,291 +88,31 @@ Status ExecEngine::Execute(ExecContext& exec_ctx, void* entry_arguments, void* r return ret; } -Status ExecEngine::BatchCompile(const std::vector>& exec_nodes, - const std::unique_ptr& func_registry) { - if (exec_nodes.empty()) { - return Status::ParseError("BatchCompile: exec_nodes is empty"); - } - - Validator validator(func_registry); - for (const auto& exec_node : exec_nodes) { - JF_RETURN_NOT_OK(validator.Validate(exec_node.get())); - } - - ResetCompiledState(); - - std::unique_ptr llvm_context = std::make_unique(); - std::unique_ptr owner = std::make_unique("module", *llvm_context); - LLVMStructType llvm_struct_type = CreateLLVMStructType(*llvm_context); - - batch_ret_types_.resize(exec_nodes.size()); - std::vector func_names; - func_names.resize(exec_nodes.size()); - - for (size_t i = 0; i < exec_nodes.size(); ++i) { - std::string func_name = kEntryFunctionName + std::to_string(i); - ValueType node_ret_type = exec_nodes[i]->GetReturnType(); - batch_ret_types_[i] = node_ret_type; - - JF_RETURN_NOT_OK(BuildEntryFunction(*llvm_context, owner, llvm_struct_type, func_name, node_ret_type, exec_nodes[i], - func_registry)); - func_names[i] = std::move(func_name); - } - JF_RETURN_NOT_OK(func_registry->SetCFuncAttr(owner.get())); - // verify - std::string error_info; - llvm::raw_string_ostream error_stream(error_info); - if (llvm::verifyModule(*owner, &error_stream)) { - return Status::RuntimeError("Module verification failed: ", error_info); - } - - JF_RETURN_NOT_OK(CreateJitAndOptimize(func_registry, std::move(owner), std::move(llvm_context))); - - batch_entry_func_ptrs_.resize(func_names.size()); - for (size_t i = 0; i < func_names.size(); ++i) { - auto func_offset = jit_->lookup(func_names[i]); - if (!func_offset) { - return Status::RuntimeError("Failed to lookup function: ", func_names[i], - ", error: ", llvm::toString(func_offset.takeError())); - } - char* func_ptr = nullptr; - func_ptr += func_offset->getValue(); - batch_entry_func_ptrs_[i] = func_ptr; - } - return Status::OK(); -} - -Status ExecEngine::ExecuteAt(size_t index, void* entry_arguments, RetType* result) { - if (index >= batch_entry_func_ptrs_.size()) { - return Status::RuntimeError("ExecuteAt: index out of range"); - } - ExecContext exec_ctx(option_.exec_ctx_arena_alloc_min_chunk_size); - char* func_ptr = batch_entry_func_ptrs_[index]; - ValueType ret_type = batch_ret_types_[index]; - EXPAND_SWITCH_TYPE(func_ptr, ret_type) - if (exec_ctx.HasErrors()) { - return Status::RuntimeError(exec_ctx.GetErrorMessage()); - } - return Status::OK(); -} - -Status ExecEngine::ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, RetType* result) { - if (index >= batch_entry_func_ptrs_.size()) { - return Status::RuntimeError("ExecuteAt: index out of range"); - } - char* func_ptr = batch_entry_func_ptrs_[index]; - ValueType ret_type = batch_ret_types_[index]; - EXPAND_SWITCH_TYPE(func_ptr, ret_type) - Status ret = Status::OK(); - if (exec_ctx.HasErrors()) { - ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); - } - exec_ctx.Clear(); - return ret; -} - -Status ExecEngine::ExecuteAt(size_t index, void* entry_arguments, void* result) { - if (index >= batch_entry_func_ptrs_.size()) { - return Status::RuntimeError("ExecuteAt: index out of range"); - } - ExecContext exec_ctx(option_.exec_ctx_arena_alloc_min_chunk_size); - reinterpret_cast(batch_entry_func_ptrs_[index])(entry_arguments, &exec_ctx, result); - if (exec_ctx.HasErrors()) { - return Status::RuntimeError(exec_ctx.GetErrorMessage()); - } - return Status::OK(); -} - -Status ExecEngine::ExecuteAt(size_t index, ExecContext& exec_ctx, void* entry_arguments, void* result) { - if (index >= batch_entry_func_ptrs_.size()) { - return Status::RuntimeError("ExecuteAt: index out of range"); - } - reinterpret_cast(batch_entry_func_ptrs_[index])(entry_arguments, &exec_ctx, result); - Status ret = Status::OK(); - if (exec_ctx.HasErrors()) { - ret = Status::RuntimeError(exec_ctx.GetErrorMessage()); - } - exec_ctx.Clear(); - return ret; -} - -Status ExecEngine::ExecuteAll(void* entry_arguments, std::vector* results) { - results->resize(batch_entry_func_ptrs_.size()); - std::string all_errors; - for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - Status st = ExecuteAt(i, entry_arguments, &(*results)[i]); - if (!st.ok()) { - if (!all_errors.empty()) { - all_errors += "| "; - } - all_errors += st.ToString(); - } - } - if (!all_errors.empty()) { - return Status::RuntimeError(all_errors); - } - return Status::OK(); -} -Status ExecEngine::ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, std::vector* results) { - results->resize(batch_entry_func_ptrs_.size()); - std::string all_errors; - for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - Status st = ExecuteAt(i, exec_ctx, entry_arguments, &(*results)[i]); - if (!st.ok()) { - if (!all_errors.empty()) { - all_errors += "| "; - } - all_errors += st.ToString(); - } - } - if (!all_errors.empty()) { - return Status::RuntimeError(all_errors); - } - return Status::OK(); -} -Status ExecEngine::ExecuteAll(void* entry_arguments, void* results) { - std::string all_errors; - for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - Status st = ExecuteAt(i, entry_arguments, results); - if (!st.ok()) { - if (!all_errors.empty()) { - all_errors += "| "; - } - all_errors += st.ToString(); - } - } - if (!all_errors.empty()) { - return Status::RuntimeError(all_errors); - } - return Status::OK(); -} -Status ExecEngine::ExecuteAll(ExecContext& exec_ctx, void* entry_arguments, void* results) { - std::string all_errors; - for (size_t i = 0; i < batch_entry_func_ptrs_.size(); ++i) { - Status st = ExecuteAt(i, exec_ctx, entry_arguments, results); - if (!st.ok()) { - if (!all_errors.empty()) { - all_errors += "| "; - } - all_errors += st.ToString(); - } - } - if (!all_errors.empty()) { - return Status::RuntimeError(all_errors); - } - return Status::OK(); -} - -Status ExecEngine::CreateJitAndOptimize(const std::unique_ptr& func_registry, - std::unique_ptr owner, - std::unique_ptr llvm_context) { - static auto machine = LLVMInit(); - const auto fp_mode = option_.fp_math_mode; - auto jit_or_err = - llvm::orc::LLJITBuilder() - .setCompileFunctionCreator([fp_mode](llvm::orc::JITTargetMachineBuilder jtmb) - -> llvm::Expected> { - jtmb.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive); - if (fp_mode == FPMathMode::kFast) { - jtmb.getOptions().AllowFPOpFusion = llvm::FPOpFusion::Fast; - jtmb.getOptions().UnsafeFPMath = true; - } - return std::make_unique(std::move(jtmb)); - }) - .create(); - if (!jit_or_err) { - return Status::RuntimeError("Failed to create LLJIT: ", llvm::toString(jit_or_err.takeError())); - } - jit_ = std::move(*jit_or_err); - auto& jd = jit_->getMainJITDylib(); - auto dlsg = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(jit_->getDataLayout().getGlobalPrefix()); - if (!dlsg) { - return Status::RuntimeError("Failed to create DynamicLibrarySearchGenerator: ", llvm::toString(dlsg.takeError())); - } - jd.addGenerator(std::move(*dlsg)); - if (option_.enable_save_compiled) { - jit_->getObjTransformLayer().setTransform( - [this](std::unique_ptr obj_buf) -> llvm::Expected> { - if (obj_buf) { - llvm::StringRef data = obj_buf->getBuffer(); - compiled_object_bytes_.assign(data.data(), data.size()); - } - return obj_buf; - }); - } - // optimize - jit_->getIRTransformLayer().setTransform( - [&, this](llvm::orc::ThreadSafeModule tsm, const llvm::orc::MaterializationResponsibility& /*r*/) { - tsm.withModuleDo([this](llvm::Module& module) { - llvm::PassBuilder pb; - - llvm::LoopAnalysisManager lam; - llvm::FunctionAnalysisManager fam; - llvm::CGSCCAnalysisManager cgam; - llvm::ModuleAnalysisManager mam; - - pb.registerPeepholeEPCallback([&](llvm::FunctionPassManager& fpm, llvm::OptimizationLevel /*level*/) { - fpm.addPass(CommutativeCallCanonicalizerPass()); - }); - - // Register all the basic analyses with the managers. - pb.registerModuleAnalyses(mam); - pb.registerCGSCCAnalyses(cgam); - pb.registerFunctionAnalyses(fam); - pb.registerLoopAnalyses(lam); - - pb.crossRegisterProxies(lam, fam, cgam, mam); - - // Create the optimization pipeline. - auto mpm = pb.buildPerModuleDefaultPipeline(llvm::OptimizationLevel::O3); - - mpm.run(module, mam); - if (option_.dump_ir) { - llvm::raw_string_ostream string_os(ir_code_); - module.print(string_os, nullptr); - } - }); - return tsm; - }); - if (auto err = jit_->addIRModule(llvm::orc::ThreadSafeModule(std::move(owner), std::move(llvm_context)))) { - return Status::RuntimeError("Failed to add module to JIT: ", llvm::toString(std::move(err))); - } - JF_RETURN_NOT_OK(func_registry->MappingToJIT(jit_.get())); - return Status::OK(); -} - Status ExecEngine::SaveCompiled(std::string* out) const { if (out == nullptr) { return Status::InvalidArgument("SaveCompiled: out must not be null"); } - const bool nothing_compiled = (entry_func_ptr_ == nullptr) && batch_entry_func_ptrs_.empty(); - if (nothing_compiled) { - return Status::RuntimeError("SaveCompiled: nothing compiled yet. Call Compile() or BatchCompile() first."); + if (entry_func_ptr_ == nullptr) { + return Status::RuntimeError("SaveCompiled: nothing compiled yet. Call Compile() first."); } - if (compiled_object_bytes_.empty()) { + const std::string_view obj = core_->GetCompiledObjectBytes(); + if (obj.empty()) { return Status::RuntimeError( "SaveCompiled: no object bytes captured. Set " - "ExecEngineOption::enable_save_compiled=true BEFORE calling Compile() / " - "BatchCompile(), then re-compile. (Artifacts loaded via LoadCompiled also " - "cannot be re-saved — the loaded bytes are intentionally not retained.)"); + "ExecEngineOption::enable_save_compiled=true BEFORE calling Compile(), " + "then re-compile. (Artifacts loaded via LoadCompiled also cannot be " + "re-saved — the loaded bytes are intentionally not retained.)"); } - const bool is_batch = !batch_entry_func_ptrs_.empty(); + const ExecEngineOption& option = core_->GetOption(); ArtifactHeader header; header.llvm_version = LLVM_VERSION_STRING; header.target_triple = llvm::sys::getProcessTriple(); header.cpu_name = llvm::sys::getHostCPUName().str(); - header.mode = is_batch ? ArtifactMode::kBatch : ArtifactMode::kSingle; - header.fp_math_mode = - (option_.fp_math_mode == FPMathMode::kFast) ? ArtifactFPMathMode::kFast : ArtifactFPMathMode::kStrict; - header.top_ret_type = is_batch ? batch_ret_types_[0] : ret_type_; - - const size_t n = is_batch ? batch_entry_func_ptrs_.size() : 1U; - header.per_entry_ret_types.resize(n); - for (size_t i = 0; i < n; ++i) { - header.per_entry_ret_types[i] = is_batch ? batch_ret_types_[i] : ret_type_; - } - return SerializeArtifact(header, compiled_object_bytes_, out); + header.mode = ArtifactMode::kSingle; + header.fp_math_mode = option.fp_math_mode; + header.per_entry_ret_types = {ret_type_}; + return SerializeArtifact(header, obj, out); } Status ExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry) { @@ -751,71 +139,30 @@ Status ExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr llvm::Expected> { - jtmb.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive); - if (fp_mode == FPMathMode::kFast) { - jtmb.getOptions().AllowFPOpFusion = llvm::FPOpFusion::Fast; - jtmb.getOptions().UnsafeFPMath = true; - } - return std::make_unique(std::move(jtmb)); - }) - .create(); - if (!jit_or_err) { - return Status::RuntimeError("LoadCompiled: failed to create LLJIT: ", llvm::toString(jit_or_err.takeError())); - } - jit_ = std::move(*jit_or_err); - - auto dlsg = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(jit_->getDataLayout().getGlobalPrefix()); - if (!dlsg) { - return Status::RuntimeError("LoadCompiled: failed to create DynamicLibrarySearchGenerator: ", - llvm::toString(dlsg.takeError())); - } - jit_->getMainJITDylib().addGenerator(std::move(*dlsg)); - auto obj_buf = - llvm::MemoryBuffer::getMemBufferCopy(llvm::StringRef(obj_view.data(), obj_view.size()), "jitfusion.loaded.o"); - if (auto err = jit_->addObjectFile(std::move(obj_buf))) { - return Status::RuntimeError("LoadCompiled: addObjectFile failed: ", llvm::toString(std::move(err))); - } - JF_RETURN_NOT_OK(func_registry->MappingToJIT(jit_.get())); - const size_t num_entries = header.per_entry_ret_types.size(); - if (is_batch) { - batch_ret_types_ = std::move(header.per_entry_ret_types); - batch_entry_func_ptrs_.resize(num_entries); - for (size_t i = 0; i < num_entries; ++i) { - const std::string sym = kEntryFunctionName + std::to_string(i); - auto off = jit_->lookup(sym); - if (!off) { - return Status::RuntimeError("LoadCompiled: entry symbol '", sym, - "' not found: ", llvm::toString(off.takeError()), - ". The FunctionRegistry is probably missing a function the artifact depends on."); - } - char* fp = nullptr; - fp += off->getValue(); - batch_entry_func_ptrs_[i] = fp; - } - } else { - ret_type_ = header.per_entry_ret_types[0]; - auto off = jit_->lookup(kEntryFunctionName); - if (!off) { - return Status::RuntimeError("LoadCompiled: entry symbol '", kEntryFunctionName, - "' not found: ", llvm::toString(off.takeError()), - ". The FunctionRegistry is probably missing a function the artifact depends on."); - } - entry_func_ptr_ = nullptr; - entry_func_ptr_ += off->getValue(); - } + if (header.mode != ArtifactMode::kSingle) { + return Status::InvalidArgument( + "compiled artifact: mode mismatch — this blob was saved by BatchExecEngine. " + "Load it with BatchExecEngine::LoadCompiled instead."); + } + + // Rebuild a JitCore that reflects the FP mode actually baked into the + // artifact (FP mode affects codegen flags, but the object bytes are + // already codegen'd — we only need the LLJIT to match so that any + // linker flags stay consistent). + ExecEngineOption new_opt = core_->GetOption(); + new_opt.fp_math_mode = header.fp_math_mode; + core_ = std::make_unique(new_opt); + + std::vector symbol_names{kEntryFunctionName}; + std::vector func_ptrs; + JF_RETURN_NOT_OK(core_->LoadObject(obj_view, symbol_names, func_registry, &func_ptrs)); + + entry_func_ptr_ = func_ptrs[0]; + // DeserializeArtifact guarantees per_entry_ret_types is non-empty + // (num_entries >= 1, and single-mode blobs specifically have exactly + // one entry). Indexing [0] is therefore always safe here. + ret_type_ = header.per_entry_ret_types[0]; return Status::OK(); } -} // namespace jitfusion \ No newline at end of file +} // namespace jitfusion diff --git a/src/execute_dispatch.h b/src/execute_dispatch.h new file mode 100644 index 0000000..0a5638f --- /dev/null +++ b/src/execute_dispatch.h @@ -0,0 +1,189 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 19:00:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 19:00:00 + */ +/* + * TU-private helpers for invoking a JIT'd entry function and converting + * its result into a variant RetType slot. + * + * Shared verbatim by src/exec_engine.cc and src/batch_exec_engine.cc. + * Kept out of any public header because: + * * The helpers depend on //Status construction — not + * something we want to force onto every TU that merely includes + * exec_engine.h. + * * EXPAND_SWITCH_TYPE is a macro, not a real function; we do NOT want + * the identifier leaking to users. The two .cc files that include + * this header therefore also `#undef JF_EXPAND_SWITCH_TYPE` at the + * bottom of their TU (optional but hygienic). + * + * Why it is a macro rather than a templated function: every switch arm + * needs a different concrete return type AND a different RetType variant + * slot assignment. A function-based factoring would end up either + * instantiating 23 specializations (O(n) template-bloat) or going + * through an extra type-erasure indirection on the hot path. The macro + * inlines the dispatch without cost and keeps all 23 arms in one place. + */ + +#pragma once + +#include +#include +#include +#include +#include "status.h" +#include "type.h" + +namespace jitfusion::execute_dispatch { + +using return_void_function_type = void (*)(void*, void*, void*); +using return_u8_function_type = std::uint8_t (*)(void*, void*, void*); +using return_u16_function_type = std::uint16_t (*)(void*, void*, void*); +using return_u32_function_type = std::uint32_t (*)(void*, void*, void*); +using return_u64_function_type = std::uint64_t (*)(void*, void*, void*); +using return_i8_function_type = std::int8_t (*)(void*, void*, void*); +using return_i16_function_type = std::int16_t (*)(void*, void*, void*); +using return_i32_function_type = std::int32_t (*)(void*, void*, void*); +using return_i64_function_type = std::int64_t (*)(void*, void*, void*); +using return_f32_function_type = float (*)(void*, void*, void*); +using return_f64_function_type = double (*)(void*, void*, void*); +using return_string_function_type = StringStruct (*)(void*, void*, void*); +using return_u8list_function_type = U8ListStruct (*)(void*, void*, void*); +using return_u16list_function_type = U16ListStruct (*)(void*, void*, void*); +using return_u32list_function_type = U32ListStruct (*)(void*, void*, void*); +using return_u64list_function_type = U64ListStruct (*)(void*, void*, void*); +using return_i8list_function_type = I8ListStruct (*)(void*, void*, void*); +using return_i16list_function_type = I16ListStruct (*)(void*, void*, void*); +using return_i32list_function_type = I32ListStruct (*)(void*, void*, void*); +using return_i64list_function_type = I64ListStruct (*)(void*, void*, void*); +using return_f32list_function_type = F32ListStruct (*)(void*, void*, void*); +using return_f64list_function_type = F64ListStruct (*)(void*, void*, void*); +using return_stringlist_function_type = StringListStruct (*)(void*, void*, void*); + +} // namespace jitfusion::execute_dispatch + +// Shared dispatch: invokes the typed function pointer and writes the +// variant slot. Expects the caller to have `entry_arguments` (void*), +// `exec_ctx` (ExecContext, taken by address), and `result` (RetType*) +// in scope — same shape as the Execute / ExecuteAt overloads. +// +// The `return Status::RuntimeError(...)` in the default branch means +// the enclosing function must return Status, which all current callers +// do. +#define JF_EXPAND_SWITCH_TYPE(func_ptr, ret_type) \ + switch (ret_type) { \ + case ::jitfusion::ValueType::kVoid: { \ + reinterpret_cast<::jitfusion::execute_dispatch::return_void_function_type>(func_ptr)(entry_arguments, &exec_ctx, \ + nullptr); \ + } break; \ + case ::jitfusion::ValueType::kU8: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_u8_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kI8: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_i8_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kU16: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_u16_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kI16: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_i16_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kU32: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_u32_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kI32: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_i32_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kU64: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_u64_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kI64: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_i64_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kF32: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_f32_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kF64: { \ + *result = reinterpret_cast<::jitfusion::execute_dispatch::return_f64_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + } break; \ + case ::jitfusion::ValueType::kString: { \ + ::jitfusion::StringStruct string = reinterpret_cast<::jitfusion::execute_dispatch::return_string_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + std::string res(string.data, string.len); \ + *result = std::move(res); \ + } break; \ + case ::jitfusion::ValueType::kU8List: { \ + ::jitfusion::U8ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_u8list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kU16List: { \ + ::jitfusion::U16ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_u16list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kU32List: { \ + ::jitfusion::U32ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_u32list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kU64List: { \ + ::jitfusion::U64ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_u64list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kI8List: { \ + ::jitfusion::I8ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_i8list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kI16List: { \ + ::jitfusion::I16ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_i16list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kI32List: { \ + ::jitfusion::I32ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_i32list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kI64List: { \ + ::jitfusion::I64ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_i64list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kF32List: { \ + ::jitfusion::F32ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_f32list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kF64List: { \ + ::jitfusion::F64ListStruct list = reinterpret_cast<::jitfusion::execute_dispatch::return_f64list_function_type>( \ + func_ptr)(entry_arguments, &exec_ctx, nullptr); \ + *result = std::vector(list.data, list.data + list.len); \ + } break; \ + case ::jitfusion::ValueType::kStringList: { \ + ::jitfusion::StringListStruct list = \ + reinterpret_cast<::jitfusion::execute_dispatch::return_stringlist_function_type>(func_ptr)( \ + entry_arguments, &exec_ctx, nullptr); \ + std::vector res; \ + res.reserve(list.len); \ + for (std::uint32_t i = 0; i < list.len; ++i) { \ + res.emplace_back(list.data[i].data, list.data[i].len); \ + } \ + *result = std::move(res); \ + } break; \ + default: \ + return ::jitfusion::Status::RuntimeError("Unsupported return type"); \ + } diff --git a/src/jit_core.cc b/src/jit_core.cc new file mode 100644 index 0000000..4a46789 --- /dev/null +++ b/src/jit_core.cc @@ -0,0 +1,372 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 18:00:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 18:00:00 + */ +#include "jit_core.h" + +#include +#include +#include +#include +#include "codegen/codegen.h" +#include "function/function_init.h" +#include "llvm/ExecutionEngine/ExecutionEngine.h" +#include "llvm/ExecutionEngine/Orc/ObjectTransformLayer.h" +#include "llvm/IR/Verifier.h" +#include "llvm/Passes/PassBuilder.h" +#include "llvm/Support/DynamicLibrary.h" +#include "llvm/Support/MemoryBuffer.h" +#include "llvm/Support/TargetSelect.h" +#include "llvm/Support/raw_ostream.h" +#include "llvm/Target/TargetMachine.h" +#include "validator.h" + +namespace jitfusion { + +const std::string kEntryFunctionName = "entry"; + +namespace { + +struct LLVMInit { + LLVMInit() { + llvm::InitializeNativeTarget(); + llvm::InitializeNativeTargetAsmPrinter(); + llvm::InitializeNativeTargetAsmParser(); + llvm::InitializeNativeTargetDisassembler(); + llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr); + } +}; + +LLVMStructType CreateLLVMStructType(llvm::LLVMContext& context) { + LLVMStructType llvm_struct_type; + auto* ptr_ty = llvm::PointerType::getUnqual(context); + auto* i32_ty = llvm::Type::getInt32Ty(context); + llvm_struct_type.string_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "StringStruct"); + llvm_struct_type.u8list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U8ListStruct"); + llvm_struct_type.u16list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U16ListStruct"); + llvm_struct_type.u32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U32ListStruct"); + llvm_struct_type.u64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "U64ListStruct"); + llvm_struct_type.i8list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I8ListStruct"); + llvm_struct_type.i16list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I16ListStruct"); + llvm_struct_type.i32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I32ListStruct"); + llvm_struct_type.i64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "I64ListStruct"); + llvm_struct_type.f32list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "F32ListStruct"); + llvm_struct_type.f64list_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "F64ListStruct"); + llvm_struct_type.stringlist_type = llvm::StructType::create(context, {ptr_ty, i32_ty}, "StringListStruct"); + return llvm_struct_type; +} + +Status GetEntryFunctionCallee(llvm::LLVMContext& context, std::unique_ptr& m, + const LLVMStructType& llvm_struct_type, const std::string& func_name, ValueType ret_type, + llvm::FunctionCallee* entry_func_callee) { + auto* ptr_ty = llvm::PointerType::getUnqual(context); + switch (ret_type) { + case ValueType::kVoid: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getVoidTy(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU8: + case ValueType::kI8: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt8Ty(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU16: + case ValueType::kI16: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt16Ty(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU32: + case ValueType::kI32: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt32Ty(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU64: + case ValueType::kI64: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getInt64Ty(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kF32: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getFloatTy(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kF64: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm::Type::getDoubleTy(context), ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kString: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.string_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU8List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u8list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU16List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u16list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU32List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u32list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kU64List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.u64list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kI8List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i8list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kI16List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i16list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kI32List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i32list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kI64List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.i64list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kF32List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.f32list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kF64List: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.f64list_type, ptr_ty, ptr_ty, ptr_ty); + } break; + case ValueType::kStringList: { + *entry_func_callee = m->getOrInsertFunction(func_name, llvm_struct_type.stringlist_type, ptr_ty, ptr_ty, ptr_ty); + } break; + default: + return Status::RuntimeError( + "[internal] unknown return type for entry function: ", TypeHelper::TypeToString(ret_type), " (compiler bug)"); + } + return Status::OK(); +} + +struct CommutativeCallCanonicalizerPass : public llvm::PassInfoMixin { + CommutativeCallCanonicalizerPass() = default; + + static llvm::PreservedAnalyses run(llvm::Function& f, llvm::FunctionAnalysisManager& /*AM*/) { + bool changed = false; + for (auto& bb : f) { + for (auto& i : bb) { + if (auto* ci = llvm::dyn_cast(&i)) { + llvm::Function* called_func = ci->getCalledFunction(); + if (called_func == nullptr) { + continue; + } + if (!called_func->hasFnAttribute(kCommutative)) { + continue; + } + if (ci->arg_size() < 2) { + continue; + } + llvm::Value* arg0 = ci->getArgOperand(0); + llvm::Value* arg1 = ci->getArgOperand(1); + if (arg0->getType() != arg1->getType()) { + continue; + } + if (ShouldSwapArguments(arg0, arg1)) { + ci->setArgOperand(0, arg1); + ci->setArgOperand(1, arg0); + changed = true; + } + } + } + } + return changed ? llvm::PreservedAnalyses::none() : llvm::PreservedAnalyses::all(); + } + + private: + static bool ShouldSwapArguments(llvm::Value* arg0, llvm::Value* arg1) { + return std::greater()(arg0, arg1); + } +}; + +Status BuildEntryFunction(llvm::LLVMContext& llvm_context, std::unique_ptr& owner, + const LLVMStructType& llvm_struct_type, const std::string& func_name, ValueType ret_type, + ExecNode* exec_node, const std::unique_ptr& func_registry) { + llvm::FunctionCallee entry_func_callee; + JF_RETURN_NOT_OK( + GetEntryFunctionCallee(llvm_context, owner, llvm_struct_type, func_name, ret_type, &entry_func_callee)); + if (auto* entry_function = llvm::dyn_cast(entry_func_callee.getCallee())) { + entry_function->addAttributeAtIndex(1, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); + entry_function->addAttributeAtIndex(1, llvm::Attribute::get(llvm_context, llvm::Attribute::ReadOnly)); + entry_function->addAttributeAtIndex(2, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); + entry_function->addAttributeAtIndex(3, llvm::Attribute::get(llvm_context, llvm::Attribute::NoAlias)); + } + + auto* entry_function = llvm::cast(entry_func_callee.getCallee()); + llvm::BasicBlock* entry_bb = llvm::BasicBlock::Create(llvm_context, "entryBB", entry_function); + llvm::IRBuilder<> builder(entry_bb); + std::unique_ptr codegen_ctx = std::make_unique( + llvm_context, *owner, builder, entry_function, llvm_struct_type, func_registry); + + CodeGen codegen(*codegen_ctx); + + llvm::Value* ret_value; + JF_RETURN_NOT_OK(codegen.GetValue(exec_node, &ret_value)); + if (ValueType::kVoid == ret_type) { + builder.CreateRetVoid(); + } else { + builder.CreateRet(ret_value); + } + return Status::OK(); +} + +} // namespace + +Status JitCore::CreateJit() { + static auto machine = LLVMInit(); + const auto fp_mode = option_.fp_math_mode; + auto jit_or_err = + llvm::orc::LLJITBuilder() + .setCompileFunctionCreator([fp_mode](llvm::orc::JITTargetMachineBuilder jtmb) + -> llvm::Expected> { + jtmb.setCodeGenOptLevel(llvm::CodeGenOptLevel::Aggressive); + if (fp_mode == FPMathMode::kFast) { + jtmb.getOptions().AllowFPOpFusion = llvm::FPOpFusion::Fast; + jtmb.getOptions().UnsafeFPMath = true; + } + return std::make_unique(std::move(jtmb)); + }) + .create(); + if (!jit_or_err) { + return Status::RuntimeError("Failed to create LLJIT: ", llvm::toString(jit_or_err.takeError())); + } + jit_ = std::move(*jit_or_err); + auto dlsg = llvm::orc::DynamicLibrarySearchGenerator::GetForCurrentProcess(jit_->getDataLayout().getGlobalPrefix()); + if (!dlsg) { + return Status::RuntimeError("Failed to create DynamicLibrarySearchGenerator: ", llvm::toString(dlsg.takeError())); + } + jit_->getMainJITDylib().addGenerator(std::move(*dlsg)); + return Status::OK(); +} + +Status JitCore::BuildAndLink(const std::vector& nodes, const std::vector& symbol_names, + const std::unique_ptr& func_registry, std::vector* out_func_ptrs, + std::vector* out_ret_types) { + if (nodes.empty()) { + return Status::ParseError("BuildAndLink: nodes is empty"); + } + if (nodes.size() != symbol_names.size()) { + return Status::RuntimeError("[internal] BuildAndLink: nodes.size() != symbol_names.size() (compiler bug)"); + } + + // Validation runs up front on caller-supplied nodes. + Validator validator(func_registry); + for (auto* node : nodes) { + JF_RETURN_NOT_OK(validator.Validate(node)); + } + + Reset(); + + auto llvm_context = std::make_unique(); + auto owner = std::make_unique("module", *llvm_context); + LLVMStructType llvm_struct_type = CreateLLVMStructType(*llvm_context); + + out_ret_types->resize(nodes.size()); + for (size_t i = 0; i < nodes.size(); ++i) { + ValueType node_ret_type = nodes[i]->GetReturnType(); + (*out_ret_types)[i] = node_ret_type; + JF_RETURN_NOT_OK(BuildEntryFunction(*llvm_context, owner, llvm_struct_type, symbol_names[i], node_ret_type, + nodes[i], func_registry)); + } + JF_RETURN_NOT_OK(func_registry->SetCFuncAttr(owner.get())); + + // Verify the module before handing it to ORC. A verifier failure here + // almost always indicates a codegen-side bug and should be surfaced + // with context rather than as a generic ORC materialization error + // later. + std::string error_info; + llvm::raw_string_ostream error_stream(error_info); + if (llvm::verifyModule(*owner, &error_stream)) { + return Status::RuntimeError("Module verification failed: ", error_info); + } + + JF_RETURN_NOT_OK(CreateJit()); + + if (option_.enable_save_compiled) { + jit_->getObjTransformLayer().setTransform( + [this](std::unique_ptr obj_buf) -> llvm::Expected> { + if (obj_buf) { + llvm::StringRef data = obj_buf->getBuffer(); + compiled_object_bytes_.assign(data.data(), data.size()); + } + return obj_buf; + }); + } + // optimize + jit_->getIRTransformLayer().setTransform( + [this](llvm::orc::ThreadSafeModule tsm, const llvm::orc::MaterializationResponsibility& /*r*/) { + tsm.withModuleDo([this](llvm::Module& module) { + llvm::PassBuilder pb; + + llvm::LoopAnalysisManager lam; + llvm::FunctionAnalysisManager fam; + llvm::CGSCCAnalysisManager cgam; + llvm::ModuleAnalysisManager mam; + + pb.registerPeepholeEPCallback([&](llvm::FunctionPassManager& fpm, llvm::OptimizationLevel /*level*/) { + fpm.addPass(CommutativeCallCanonicalizerPass()); + }); + + // Register all the basic analyses with the managers. + pb.registerModuleAnalyses(mam); + pb.registerCGSCCAnalyses(cgam); + pb.registerFunctionAnalyses(fam); + pb.registerLoopAnalyses(lam); + + pb.crossRegisterProxies(lam, fam, cgam, mam); + + auto mpm = pb.buildPerModuleDefaultPipeline(llvm::OptimizationLevel::O3); + + mpm.run(module, mam); + if (option_.dump_ir) { + llvm::raw_string_ostream string_os(ir_code_); + module.print(string_os, nullptr); + } + }); + return tsm; + }); + if (auto err = jit_->addIRModule(llvm::orc::ThreadSafeModule(std::move(owner), std::move(llvm_context)))) { + return Status::RuntimeError("Failed to add module to JIT: ", llvm::toString(std::move(err))); + } + JF_RETURN_NOT_OK(func_registry->MappingToJIT(jit_.get())); + + out_func_ptrs->resize(symbol_names.size()); + for (size_t i = 0; i < symbol_names.size(); ++i) { + auto off = jit_->lookup(symbol_names[i]); + if (!off) { + return Status::RuntimeError("Failed to lookup function: ", symbol_names[i], + ", error: ", llvm::toString(off.takeError())); + } + char* func_ptr = nullptr; + func_ptr += off->getValue(); + (*out_func_ptrs)[i] = func_ptr; + } + return Status::OK(); +} + +Status JitCore::LoadObject(std::string_view object_bytes, const std::vector& symbol_names, + const std::unique_ptr& func_registry, std::vector* out_func_ptrs) { + Reset(); + JF_RETURN_NOT_OK(CreateJit()); + + auto obj_buf = llvm::MemoryBuffer::getMemBufferCopy(llvm::StringRef(object_bytes.data(), object_bytes.size()), + "jitfusion.loaded.o"); + if (auto err = jit_->addObjectFile(std::move(obj_buf))) { + return Status::RuntimeError("LoadCompiled: addObjectFile failed: ", llvm::toString(std::move(err))); + } + JF_RETURN_NOT_OK(func_registry->MappingToJIT(jit_.get())); + + out_func_ptrs->resize(symbol_names.size()); + for (size_t i = 0; i < symbol_names.size(); ++i) { + auto off = jit_->lookup(symbol_names[i]); + if (!off) { + return Status::RuntimeError("LoadCompiled: entry symbol '", symbol_names[i], + "' not found: ", llvm::toString(off.takeError()), + ". The FunctionRegistry is probably missing a function the artifact depends on."); + } + char* fp = nullptr; + fp += off->getValue(); + (*out_func_ptrs)[i] = fp; + } + return Status::OK(); +} + +void JitCore::Reset() { + jit_.reset(); + ir_code_.clear(); + compiled_object_bytes_.clear(); +} + +} // namespace jitfusion diff --git a/src/jit_core.h b/src/jit_core.h new file mode 100644 index 0000000..f37eac0 --- /dev/null +++ b/src/jit_core.h @@ -0,0 +1,98 @@ +/* + * @Author: victorika + * @Date: 2026-05-07 18:00:00 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-07 18:00:00 + */ +/* + * Private, non-public helper shared by ExecEngine and BatchExecEngine. + * + * JitCore owns the LLJIT instance plus the small amount of per-compile + * bookkeeping that is identical for single-expression and multi-expression + * compilation: + * * LLJIT construction with the correct FP math options + * * Dynamic-library resolver wiring + * * Optional capture of the raw object bytes (for SaveCompiled) + * * Optional capture of the fully-optimized IR text (for GetIRCode) + * * Symbol lookup after materialization + * * Bulk compile helper that takes (N ExecNode roots, N symbol names) + * and returns (N function pointers, N return types). + * + * This header is PRIVATE (src/ only). Public headers must not include it + * — it drags in LLVM and defeats the "minimal public surface" promise of + * include/exec_engine.h. + */ + +#pragma once + +#include +#include +#include +#include +#include +#include "exec_node.h" +#include "exec_options.h" // FPMathMode / ExecEngineOption +#include "function_registry.h" +#include "llvm/ExecutionEngine/Orc/LLJIT.h" +#include "status.h" +#include "type.h" + +namespace jitfusion { + +// Deterministic symbol-naming convention shared by Save and Load: +// single mode -> "entry" +// batch mode entry i -> "entry" + std::to_string(i) +extern const std::string kEntryFunctionName; + +class JitCore { + public: + explicit JitCore(ExecEngineOption option) : option_(option) {} + ~JitCore() = default; + JitCore(const JitCore&) = delete; + JitCore& operator=(const JitCore&) = delete; + + // Compile N ExecNode roots into N entry functions with the supplied + // symbol names, optimize with the O3 pipeline, and resolve each symbol + // to a host function pointer. + // + // On success: + // *out_func_ptrs receives N entry function pointers (same order) + // *out_ret_types receives the ValueType of each root's result + // GetIRCode() and (if enabled) the captured object bytes are + // populated as a side effect. + // + // On failure: the JitCore is left reset (no partial state). + Status BuildAndLink(const std::vector& nodes, const std::vector& symbol_names, + const std::unique_ptr& func_registry, std::vector* out_func_ptrs, + std::vector* out_ret_types); + + // Take a previously-serialized relocatable object buffer and install it + // into a fresh LLJIT. Resolves each symbol in `symbol_names` to a host + // function pointer. Used by LoadCompiled. + // + // Caller is responsible for having validated the object bytes' LLVM + // version / target triple / CPU compatibility before calling this. + Status LoadObject(std::string_view object_bytes, const std::vector& symbol_names, + const std::unique_ptr& func_registry, std::vector* out_func_ptrs); + + // Drop the LLJIT and any captured bytes / IR text. Safe to call on a + // never-compiled instance. + void Reset(); + + // Accessors used by SaveCompiled / GetIRCode at the public-class layer. + [[nodiscard]] std::string_view GetIRCode() const { return ir_code_; } + [[nodiscard]] std::string_view GetCompiledObjectBytes() const { return compiled_object_bytes_; } + [[nodiscard]] const ExecEngineOption& GetOption() const { return option_; } + + private: + // Shared between BuildAndLink and LoadObject: construct a fresh LLJIT + // with the right FP options and add the process dylib resolver. + Status CreateJit(); + + ExecEngineOption option_; + std::unique_ptr jit_; + std::string ir_code_; + std::string compiled_object_bytes_; +}; + +} // namespace jitfusion diff --git a/test/exec_error_test.cc b/test/exec_error_test.cc index 1ebc512..2d5c772 100644 --- a/test/exec_error_test.cc +++ b/test/exec_error_test.cc @@ -10,6 +10,7 @@ #include #include #include +#include "batch_exec_engine.h" #include "exec_engine.h" #include "exec_node.h" #include "function_registry.h" @@ -80,8 +81,8 @@ TEST(ExecErrorTest, ExecuteAtReturnsRuntimeError) { nodes.emplace_back(MakeSimpleAddNode(1, 2)); nodes.emplace_back(MakeListAddNode({1, 2, 3}, {4, 5})); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); RetType result0; Status st0 = exec_engine.ExecuteAt(0, nullptr, &result0); @@ -101,8 +102,8 @@ TEST(ExecErrorTest, ExecuteAtWithCtxReturnsRuntimeErrorAndClears) { std::vector> nodes; nodes.emplace_back(MakeListAddNode({1, 2, 3}, {4, 5})); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); ExecContext exec_ctx(4096); RetType result; @@ -119,8 +120,8 @@ TEST(ExecErrorTest, ExecuteAtOutOfRange) { std::vector> nodes; nodes.emplace_back(MakeSimpleAddNode(1, 2)); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); RetType result; Status st = exec_engine.ExecuteAt(999, nullptr, &result); @@ -138,8 +139,8 @@ TEST(ExecErrorTest, ExecuteAllPartialFailureCollectsAllErrors) { nodes.emplace_back(MakeSimpleAddNode(100, 200)); nodes.emplace_back(MakeListAddNode({1}, {4, 5, 6})); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); std::vector results; Status st = exec_engine.ExecuteAll(nullptr, &results); @@ -169,8 +170,8 @@ TEST(ExecErrorTest, ExecuteAllWithCtxPartialFailure) { nodes.emplace_back(MakeListAddNode({1, 2}, {4, 5, 6})); nodes.emplace_back(MakeSimpleAddNode(3, 4)); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); ExecContext exec_ctx(4096); std::vector results; @@ -218,8 +219,8 @@ TEST(ExecErrorTest, BatchCompileAndExecuteAllSuccess) { nodes.emplace_back(MakeSimpleAddNode(100, 200)); nodes.emplace_back(MakeSimpleAddNode(1000, 2000)); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); std::vector results; Status st = exec_engine.ExecuteAll(nullptr, &results); @@ -239,8 +240,8 @@ TEST(ExecErrorTest, BatchCompileAndExecuteAllWithCtxSuccess) { nodes.emplace_back(MakeSimpleAddNode(5, 7)); nodes.emplace_back(MakeSimpleAddNode(11, 13)); - ExecEngine exec_engine; - ASSERT_TRUE(exec_engine.BatchCompile(nodes, func_registry).ok()); + BatchExecEngine exec_engine; + ASSERT_TRUE(exec_engine.Compile(nodes, func_registry).ok()); ExecContext exec_ctx(4096); std::vector results; diff --git a/test/save_load_test.cc b/test/save_load_test.cc index 2994e31..3931e2b 100644 --- a/test/save_load_test.cc +++ b/test/save_load_test.cc @@ -22,6 +22,7 @@ #include #include #include +#include "batch_exec_engine.h" #include "exec_engine.h" #include "exec_node.h" #include "function_registry.h" @@ -197,20 +198,20 @@ TEST(SaveLoadTest, BatchCompileRoundTrip) { nodes.emplace_back(new ConstantValueNode(static_cast(2.5))); nodes.emplace_back(new ConstantValueNode(std::string("batched"))); - ExecEngine src(SaveCapableOption()); - ASSERT_TRUE(src.BatchCompile(nodes, reg).ok()); - ASSERT_EQ(src.GetBatchFunctionCount(), 3u); + BatchExecEngine src(SaveCapableOption()); + ASSERT_TRUE(src.Compile(nodes, reg).ok()); + ASSERT_EQ(src.GetFunctionCount(), 3u); std::string blob; ASSERT_TRUE(src.SaveCompiled(&blob).ok()); - ExecEngine dst; + BatchExecEngine dst; auto reg2 = MakeRegistry(); ASSERT_TRUE(dst.LoadCompiled(blob, reg2).ok()); - ASSERT_EQ(dst.GetBatchFunctionCount(), 3u); - EXPECT_EQ(dst.GetBatchFunctionReturnType(0), ValueType::kI32); - EXPECT_EQ(dst.GetBatchFunctionReturnType(1), ValueType::kF64); - EXPECT_EQ(dst.GetBatchFunctionReturnType(2), ValueType::kString); + ASSERT_EQ(dst.GetFunctionCount(), 3u); + EXPECT_EQ(dst.GetReturnType(0), ValueType::kI32); + EXPECT_EQ(dst.GetReturnType(1), ValueType::kF64); + EXPECT_EQ(dst.GetReturnType(2), ValueType::kString); RetType r; ASSERT_TRUE(dst.ExecuteAt(0, nullptr, &r).ok()); From 511a2ffa32210cb36bfd7176d7babd6dbab83f02 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 11:16:00 +0800 Subject: [PATCH 25/41] support skip LoadCompiled check with LoadCompiledOptions --- include/batch_exec_engine.h | 8 +++++-- include/exec_engine.h | 8 +++++-- include/exec_options.h | 42 +++++++++++++++++++++++++++++++++++++ src/batch_exec_engine.cc | 29 ++++--------------------- src/compiled_artifact.cc | 30 ++++++++++++++++++++++++++ src/compiled_artifact.h | 23 ++++++++++++++++++++ src/exec_engine.cc | 29 ++++--------------------- 7 files changed, 115 insertions(+), 54 deletions(-) diff --git a/include/batch_exec_engine.h b/include/batch_exec_engine.h index a7031e6..bba7e5c 100644 --- a/include/batch_exec_engine.h +++ b/include/batch_exec_engine.h @@ -94,7 +94,10 @@ class BatchExecEngine { // FunctionRegistry. // // Compatibility contract (same as ExecEngine): - // * LLVM version / target triple / CPU must match exactly. + // * LLVM version / target triple / CPU must match exactly by + // default. Individual checks can be relaxed through + // LoadCompiledOptions if the caller knows the divergence is + // safe (see that struct for the hazards). // * FunctionRegistry must re-register every C function the saved // expression depends on under the same FunctionSignature. // * GetIRCode() is empty after LoadCompiled — IR is never rebuilt. @@ -106,7 +109,8 @@ class BatchExecEngine { // blob into ExecEngine (or vice versa) fails cleanly with a mode // mismatch message. Status SaveCompiled(std::string* out) const; - Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry); + Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry, + const LoadCompiledOptions& opts = {}); private: std::unique_ptr core_; diff --git a/include/exec_engine.h b/include/exec_engine.h index 6271db5..142a23d 100644 --- a/include/exec_engine.h +++ b/include/exec_engine.h @@ -71,7 +71,10 @@ class ExecEngine { // on subsequent runs. // // Compatibility contract: - // * LLVM version / target triple / CPU must match exactly. + // * LLVM version / target triple / CPU must match exactly by + // default. Individual checks can be relaxed through + // LoadCompiledOptions if the caller knows the divergence is + // safe (see that struct for the hazards). // * The FunctionRegistry passed to LoadCompiled must re-register // every C function referenced by the original expression under // the same FunctionSignature; addresses may differ across @@ -87,7 +90,8 @@ class ExecEngine { // ExecEngine (or vice versa) fails cleanly with a mode mismatch // message. Status SaveCompiled(std::string* out) const; - Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry); + Status LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry, + const LoadCompiledOptions& opts = {}); private: std::unique_ptr core_; diff --git a/include/exec_options.h b/include/exec_options.h index 9bc1864..6b3a97e 100644 --- a/include/exec_options.h +++ b/include/exec_options.h @@ -130,4 +130,46 @@ struct ExecEngineOption { bool enable_save_compiled{false}; }; +// Policy knobs controlling which host-compatibility checks +// ExecEngine::LoadCompiled / BatchExecEngine::LoadCompiled apply to the +// incoming artifact header before handing the bytes to the JIT. +// +// DEFAULTS ARE CONSERVATIVE — every check is on. Flipping any of them +// to false is a *load-at-your-own-risk* decision: the JIT does not do +// any of these checks itself, and an artifact produced on an +// incompatible host can surface as SIGILL (illegal instruction) or +// silently wrong results the first time a divergent code path runs. +// Only disable a check when you control both the producer and the +// consumer, and you are deliberately relaxing the matching rule +// (e.g. ignoring cpu_name when you know the CPU families are +// binary-compatible for the feature set your codegen uses). +// +// The `mode` check is intentionally NOT exposed as an option: a +// single-mode blob loaded into BatchExecEngine (or vice versa) fails +// at symbol lookup regardless, so relaxing it buys nothing and loses +// the good error message. +struct LoadCompiledOptions { + // Compare LLVM_VERSION_STRING baked into the artifact against the + // runtime's. Differing major versions can quietly change IR / object + // semantics (intrinsics, runtime helpers, debug info, ...). Keeping + // this on is strongly recommended. + bool check_llvm_version{true}; + + // Compare the target triple (OS / vendor / ABI) baked into the + // artifact against llvm::sys::getProcessTriple(). Disabling lets a + // linux-gnu blob load into a linux-musl process (or similar); only + // safe if the libc / syscall surfaces your registered C functions + // touch are actually compatible. + bool check_target_triple{true}; + + // Compare the host CPU name baked into the artifact against + // llvm::sys::getHostCPUName(). The CPU name governs which + // instruction-set extensions the codegen was allowed to emit + // (AVX-512, SVE, ...). Disabling lets the same blob run across + // different CPU SKUs in the same family, but an instruction that is + // not supported on the consumer CPU will fault as SIGILL the first + // time it executes. + bool check_cpu_name{true}; +}; + } // namespace jitfusion diff --git a/src/batch_exec_engine.cc b/src/batch_exec_engine.cc index 6fd0f4b..5484bb1 100644 --- a/src/batch_exec_engine.cc +++ b/src/batch_exec_engine.cc @@ -201,35 +201,14 @@ Status BatchExecEngine::SaveCompiled(std::string* out) const { return SerializeArtifact(header, obj, out); } -Status BatchExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry) { +Status BatchExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry, + const LoadCompiledOptions& opts) { ArtifactHeader header; std::string_view obj_view; JF_RETURN_NOT_OK(DeserializeArtifact(bytes, &header, &obj_view)); - if (header.llvm_version != LLVM_VERSION_STRING) { - return Status::InvalidArgument( - "compiled artifact: LLVM version mismatch (artifact=", header.llvm_version, ", runtime=", LLVM_VERSION_STRING, - "). LLVM does not guarantee object-file compatibility across versions; regenerate the artifact."); - } - { - const std::string current_triple = llvm::sys::getProcessTriple(); - if (header.target_triple != current_triple) { - return Status::InvalidArgument("compiled artifact: target triple mismatch (artifact=", header.target_triple, - ", runtime=", current_triple, ")"); - } - } - { - const std::string current_cpu = llvm::sys::getHostCPUName().str(); - if (header.cpu_name != current_cpu) { - return Status::InvalidArgument("compiled artifact: host CPU mismatch (artifact=", header.cpu_name, - ", runtime=", current_cpu, "). Regenerate the artifact on this host."); - } - } - if (header.mode != ArtifactMode::kBatch) { - return Status::InvalidArgument( - "compiled artifact: mode mismatch — this blob was saved by ExecEngine. " - "Load it with ExecEngine::LoadCompiled instead."); - } + JF_RETURN_NOT_OK(CheckHostCompatibility(header, opts, LLVM_VERSION_STRING, llvm::sys::getProcessTriple(), + llvm::sys::getHostCPUName().str(), ArtifactMode::kBatch)); ExecEngineOption new_opt = core_->GetOption(); new_opt.fp_math_mode = header.fp_math_mode; diff --git a/src/compiled_artifact.cc b/src/compiled_artifact.cc index f952d80..2c55b07 100644 --- a/src/compiled_artifact.cc +++ b/src/compiled_artifact.cc @@ -291,4 +291,34 @@ Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, st return Status::OK(); } +Status CheckHostCompatibility(const ArtifactHeader& header, const LoadCompiledOptions& opts, + std::string_view host_llvm_version, std::string_view host_target_triple, + std::string_view host_cpu_name, ArtifactMode expected_mode) { + if (opts.check_llvm_version && header.llvm_version != host_llvm_version) { + return Status::InvalidArgument( + "compiled artifact: LLVM version mismatch (artifact=", header.llvm_version, ", runtime=", host_llvm_version, + "). LLVM does not guarantee object-file compatibility across versions; regenerate the artifact."); + } + if (opts.check_target_triple && header.target_triple != host_target_triple) { + return Status::InvalidArgument("compiled artifact: target triple mismatch (artifact=", header.target_triple, + ", runtime=", host_target_triple, ")"); + } + if (opts.check_cpu_name && header.cpu_name != host_cpu_name) { + return Status::InvalidArgument("compiled artifact: host CPU mismatch (artifact=", header.cpu_name, + ", runtime=", host_cpu_name, "). Regenerate the artifact on this host."); + } + if (header.mode != expected_mode) { + // Mode mismatch is not user-suppressible: the other engine's + // symbol-naming scheme does not match, so lookup would fail later + // with a much worse error anyway. Surface the right guidance up + // front. + const char* wrong = (expected_mode == ArtifactMode::kSingle) ? "BatchExecEngine" : "ExecEngine"; + const char* right = + (expected_mode == ArtifactMode::kSingle) ? "ExecEngine::LoadCompiled" : "BatchExecEngine::LoadCompiled"; + return Status::InvalidArgument("compiled artifact: mode mismatch — this blob was saved by ", wrong, + ". Load it with ", right, " instead."); + } + return Status::OK(); +} + } // namespace jitfusion diff --git a/src/compiled_artifact.h b/src/compiled_artifact.h index ec8aeb9..8357a0a 100644 --- a/src/compiled_artifact.h +++ b/src/compiled_artifact.h @@ -169,4 +169,27 @@ Status SerializeArtifact(const ArtifactHeader& header, std::string_view object_b // level. Deserialize only guarantees the bytes parsed cleanly. Status DeserializeArtifact(std::string_view blob, ArtifactHeader* out_header, std::string_view* out_object_bytes); +// Apply the host-compatibility checks shared by ExecEngine::LoadCompiled +// and BatchExecEngine::LoadCompiled. +// +// The three `host_*` strings must be supplied by the caller (usually +// the engine, which pulls them from llvm::sys::getProcessTriple() and +// friends). We keep LLVM out of this translation unit on purpose, so +// the artifact serde stays unit-testable without spinning up a JIT. +// +// Each check can be independently suppressed via `opts`. The `mode` +// check is also performed here but is not user-suppressible: a mode +// mismatch means the caller reached for the wrong engine class, and +// loading would fail at symbol lookup anyway with a much worse error. +// +// `expected_mode` is the mode the calling engine expects (kSingle for +// ExecEngine, kBatch for BatchExecEngine); the error message mentions +// which engine the caller should have used instead. +// +// Returns Status::InvalidArgument on mismatch, with a message prefixed +// "compiled artifact: " so it joins the other artifact errors in logs. +Status CheckHostCompatibility(const ArtifactHeader& header, const LoadCompiledOptions& opts, + std::string_view host_llvm_version, std::string_view host_target_triple, + std::string_view host_cpu_name, ArtifactMode expected_mode); + } // namespace jitfusion diff --git a/src/exec_engine.cc b/src/exec_engine.cc index ad965f7..d5ff70b 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -115,35 +115,14 @@ Status ExecEngine::SaveCompiled(std::string* out) const { return SerializeArtifact(header, obj, out); } -Status ExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry) { +Status ExecEngine::LoadCompiled(std::string_view bytes, const std::unique_ptr& func_registry, + const LoadCompiledOptions& opts) { ArtifactHeader header; std::string_view obj_view; JF_RETURN_NOT_OK(DeserializeArtifact(bytes, &header, &obj_view)); - if (header.llvm_version != LLVM_VERSION_STRING) { - return Status::InvalidArgument( - "compiled artifact: LLVM version mismatch (artifact=", header.llvm_version, ", runtime=", LLVM_VERSION_STRING, - "). LLVM does not guarantee object-file compatibility across versions; regenerate the artifact."); - } - { - const std::string current_triple = llvm::sys::getProcessTriple(); - if (header.target_triple != current_triple) { - return Status::InvalidArgument("compiled artifact: target triple mismatch (artifact=", header.target_triple, - ", runtime=", current_triple, ")"); - } - } - { - const std::string current_cpu = llvm::sys::getHostCPUName().str(); - if (header.cpu_name != current_cpu) { - return Status::InvalidArgument("compiled artifact: host CPU mismatch (artifact=", header.cpu_name, - ", runtime=", current_cpu, "). Regenerate the artifact on this host."); - } - } - if (header.mode != ArtifactMode::kSingle) { - return Status::InvalidArgument( - "compiled artifact: mode mismatch — this blob was saved by BatchExecEngine. " - "Load it with BatchExecEngine::LoadCompiled instead."); - } + JF_RETURN_NOT_OK(CheckHostCompatibility(header, opts, LLVM_VERSION_STRING, llvm::sys::getProcessTriple(), + llvm::sys::getHostCPUName().str(), ArtifactMode::kSingle)); // Rebuild a JitCore that reflects the FP mode actually baked into the // artifact (FP mode affects codegen flags, but the object bytes are From a8a7566a303deaa340948f8e3db12e14e119bbea Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 11:32:43 +0800 Subject: [PATCH 26/41] update gh_pages --- .github/workflows/pages.yml | 65 +++++++++++++++++++++++++++ .gitignore | 10 ++++- _config.yml | 88 +++++++++++++++++++++++++++++++++++++ athena/README.md | 7 +++ doc/function.md | 8 ++++ index.md | 19 ++++++++ 6 files changed, 196 insertions(+), 1 deletion(-) create mode 100644 .github/workflows/pages.yml create mode 100644 _config.yml create mode 100644 index.md diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml new file mode 100644 index 0000000..fd5b82d --- /dev/null +++ b/.github/workflows/pages.yml @@ -0,0 +1,65 @@ +# Publish the Jekyll site under the repo root to GitHub Pages. +# +# Split into build + deploy, per GitHub's recommended template, so: +# * Build runs in a generic runner, no Pages write permissions needed. +# * Deploy runs in the isolated `github-pages` environment that the +# repository's Pages settings protect. +# +# Pages source MUST be set to "GitHub Actions" (Settings → Pages → Build +# and deployment → Source). With the classic "Deploy from a branch" +# setting this workflow has no effect. +name: Pages + +on: + push: + branches: [main] + # Allow manual redeploys from the Actions tab, handy for retrying a + # flaky remote-theme fetch without having to push an empty commit. + workflow_dispatch: + +# One in-flight deploy at a time; cancel older runs if a newer push +# supersedes them. This matches the GitHub template exactly and avoids +# a race where an older successful build overwrites a newer one. +concurrency: + group: pages + cancel-in-progress: true + +permissions: + contents: read + pages: write + id-token: write + +jobs: + build: + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + + - name: Setup Pages + # Emits `base_path` for downstream steps — we pass it through to + # the Jekyll builder so URLs render with the correct /JitFusion + # prefix on forks as well (a fork's Pages URL has a different + # repo-name segment, so hard-coding baseurl here would break it). + id: pages + uses: actions/configure-pages@v5 + + - name: Build with Jekyll + uses: actions/jekyll-build-pages@v1 + with: + source: ./ + destination: ./_site + + - name: Upload artifact + uses: actions/upload-pages-artifact@v3 + + deploy: + needs: build + runs-on: ubuntu-latest + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - name: Deploy to GitHub Pages + id: deployment + uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore index ef566c7..8450ce8 100644 --- a/.gitignore +++ b/.gitignore @@ -7,4 +7,12 @@ MODULE.bazel.lock /build /cmake-build* /out -.bazelrc \ No newline at end of file +.bazelrc + +# Jekyll (GitHub Pages) — only relevant for local previews; CI builds +# happen in an ephemeral runner and never commit these back. +/_site +/.jekyll-cache +/.jekyll-metadata +/vendor +/Gemfile.lock \ No newline at end of file diff --git a/_config.yml b/_config.yml new file mode 100644 index 0000000..e79181e --- /dev/null +++ b/_config.yml @@ -0,0 +1,88 @@ +title: JitFusion +description: A high-performance execution engine based on LLVM JIT. +# Served from https://viktorika.github.io/JitFusion/ — the trailing +# slash matters: links rendered by Jekyll are resolved against this +# URL, so a missing baseurl would silently produce broken nav on +# GitHub Pages. +url: https://viktorika.github.io +baseurl: /JitFusion + +# --------------------------------------------------------------------------- +# Theme +# --------------------------------------------------------------------------- +# We use `just-the-docs` via `remote_theme` so the site does not need a +# Gemfile / bundler on the runner: GitHub Pages and `actions/jekyll-build-pages` +# both fetch the gem transparently. If you ever want local preview, do +# `bundle init && bundle add jekyll just-the-docs webrick` — neither is +# required in CI. +remote_theme: just-the-docs/just-the-docs + +# Enable the built-in client-side search bundled with just-the-docs. It +# indexes at build time into a JSON file, so there is no runtime cost or +# external service. +search_enabled: true +search: + heading_level: 3 + previews: 3 + +# Color scheme and top-right GitHub button. +color_scheme: light +aux_links: + "GitHub": + - "https://github.com/viktorika/JitFusion" + +# --------------------------------------------------------------------------- +# What Jekyll should (and must not) process +# --------------------------------------------------------------------------- +# The repo root contains a lot of non-doc content that is either huge +# (generated parsers), meaningless on a web page (Bazel metadata), or +# actively harmful if Jekyll tries to render it as Liquid (C++ source +# with `{{` / `{%` sequences would crash the build). We list every such +# path here rather than relying on include-lists so that *adding* a new +# Markdown doc just works without editing this file. +exclude: + - BUILD + - MODULE.bazel + - WORKSPACE + - CMakeLists.txt + - LICENSE + - llvm_repository.bzl + - .bazelversion + - .clang-tidy + - .gitignore + - Gemfile + - Gemfile.lock + - vendor/ + - node_modules/ + - cmake-build/ + - build/ + - out/ + - bazel-bin/ + - bazel-out/ + - bazel-testlogs/ + - bazel-JitFusion/ + - src/ + - include/ + - test/ + - benchmark/ + - athena/ast_builder.cc + - athena/ast_builder.h + - athena/athena.cc + - athena/athena.h + - athena/dsu.cc + - athena/dsu.h + - athena/gen_parser.sh + - athena/location.hh + - athena/parser.cc + - athena/parser.hh + - athena/parser.yy + - athena/pipeline_grouper.cc + - athena/pipeline_grouper.h + - athena/token.cc + - athena/token.ll + - athena/test/ + +# Plugins available on GitHub Pages without a Gemfile. +plugins: + - jekyll-remote-theme + - jekyll-seo-tag diff --git a/athena/README.md b/athena/README.md index 2803b05..30f99c2 100644 --- a/athena/README.md +++ b/athena/README.md @@ -1,3 +1,10 @@ +--- +title: Athena DSL +nav_order: 2 +# Published under /JitFusion/athena/ — the URL keeps the directory +# layout so relative links from other pages stay stable. +--- + # athena An execution engine utilizing DSL in combination with jitfusion. diff --git a/doc/function.md b/doc/function.md index e65094b..fc52afe 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1,3 +1,11 @@ +--- +title: Function Reference +nav_order: 3 +# This file is large (~1500 lines). just-the-docs renders it as a +# single long page with a right-hand TOC built from the `##` headings, +# which is exactly what we want for a function catalog. +--- + # function The following are the currently supported functions: diff --git a/index.md b/index.md new file mode 100644 index 0000000..67dff6b --- /dev/null +++ b/index.md @@ -0,0 +1,19 @@ +--- +title: Home +layout: home +nav_order: 1 +# The site root. We deliberately do NOT duplicate the README's content +# into this file. Instead we pull it in at build time with +# `include_relative`, so this page always matches whatever is on the +# repo front page without manual sync. The trade-off is that Liquid +# tags inside the README (`{{ ... }}` / `{% ... %}`) would be +# interpreted — but the README contains neither today and we'd catch +# it instantly if one were added (Jekyll build fails loudly). +# +# Note: relative image paths inside the included README (e.g. +# `doc/exec_pipeline_example.png`) resolve against THIS file's +# location (the repo root), not against the README's location — +# which happens to be the same directory, so everything lines up. +--- + +{% include_relative README.md %} From 640709c700f98128dbe3c0b45d82cd53d8b78458 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 12:29:44 +0800 Subject: [PATCH 27/41] fix deploy --- .github/workflows/pages.yml | 50 +++++++++++++++++++++++++++++++++++-- _config.yml | 10 +++++++- 2 files changed, 57 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index fd5b82d..8f54226 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -11,10 +11,27 @@ name: Pages on: - push: + # Deploy is chained off the `Benchmark` workflow rather than listening + # to `push` directly. Rationale: + # * Benchmark already runs on every push to main, and it is the + # slower of the two pipelines. + # * Waiting for it to finish means the `dev/bench/` tree on the + # `gh-pages` branch is already refreshed by the time we graft it + # into `_site/`, so a single deploy per push is enough to publish + # BOTH the latest docs (README etc.) AND the latest benchmark. + # * A push that only touches docs still triggers benchmark.yml, so + # this chain fires regardless of what changed. The small cost is + # that pure-docs updates have to wait for the benchmark job. + # The `branches` filter + the `conclusion == success` gate below + # together ensure we only deploy for successful main-branch runs. + workflow_run: + workflows: ["Benchmark"] + types: [completed] branches: [main] # Allow manual redeploys from the Actions tab, handy for retrying a - # flaky remote-theme fetch without having to push an empty commit. + # flaky remote-theme fetch without having to push an empty commit, + # and as an escape hatch if you want to republish without waiting for + # a benchmark run (e.g. README-only fix while benchmark is broken). workflow_dispatch: # One in-flight deploy at a time; cancel older runs if a newer push @@ -32,6 +49,11 @@ permissions: jobs: build: runs-on: ubuntu-latest + # For `workflow_run` triggers, only proceed if the upstream Benchmark + # run succeeded. Other triggers (push / workflow_dispatch) evaluate + # to `true` because `github.event.workflow_run` is null, which the + # `!=` comparison handles correctly. + if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }} steps: - name: Checkout uses: actions/checkout@v4 @@ -50,6 +72,30 @@ jobs: source: ./ destination: ./_site + # Merge benchmark history published by `benchmark.yml` into the + # Jekyll output. The benchmark workflow keeps pushing new data to + # the `gh-pages` branch (under `dev/bench/`) via + # benchmark-action/github-action-benchmark; after we flipped the + # Pages source to "GitHub Actions", that branch is no longer + # auto-served, so we have to graft its `dev/` tree onto `_site/` + # here. Missing branch is tolerated (fresh forks without any + # benchmark run yet). + - name: Merge benchmark results from gh-pages + run: | + set -euo pipefail + if git ls-remote --exit-code --heads origin gh-pages >/dev/null 2>&1; then + tmp="$(mktemp -d)" + git clone --depth 1 --branch gh-pages \ + "https://github.com/${GITHUB_REPOSITORY}.git" "$tmp" + if [ -d "$tmp/dev" ]; then + mkdir -p ./_site/dev + cp -R "$tmp/dev/." ./_site/dev/ + fi + rm -rf "$tmp" + else + echo "gh-pages branch not found yet; skipping benchmark merge." + fi + - name: Upload artifact uses: actions/upload-pages-artifact@v3 diff --git a/_config.yml b/_config.yml index e79181e..2206435 100644 --- a/_config.yml +++ b/_config.yml @@ -25,11 +25,19 @@ search: heading_level: 3 previews: 3 -# Color scheme and top-right GitHub button. +# Color scheme and top-right nav buttons. `Benchmarks` points into +# `dev/bench/`, which is NOT built by Jekyll — it is grafted onto +# `_site/` by the Pages workflow from the `gh-pages` branch, where +# benchmark-action/github-action-benchmark keeps publishing history +# from `benchmark.yml`. Using a site-relative link via `baseurl` keeps +# the button working on forks too (their Pages URL has a different +# repo-name segment). color_scheme: light aux_links: "GitHub": - "https://github.com/viktorika/JitFusion" + "Benchmarks": + - "{{ site.baseurl }}/dev/bench/" # --------------------------------------------------------------------------- # What Jekyll should (and must not) process From 2b94b663cb56606c04ec9af755047378183ce6cb Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 12:43:57 +0800 Subject: [PATCH 28/41] fix deploy --- .github/workflows/pages.yml | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index 8f54226..6915323 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -80,9 +80,18 @@ jobs: # auto-served, so we have to graft its `dev/` tree onto `_site/` # here. Missing branch is tolerated (fresh forks without any # benchmark run yet). + # + # NOTE on the `sudo chown` below: `actions/jekyll-build-pages` is + # a Docker action that runs as root inside a container, so + # `./_site` is created owned by root. This step runs on the host + # as the unprivileged `runner` user, which cannot otherwise write + # into `_site/`. Fix up ownership once before touching it; the + # upload-pages-artifact step that follows doesn't care about + # ownership, only about contents. - name: Merge benchmark results from gh-pages run: | set -euo pipefail + sudo chown -R "$(id -u):$(id -g)" ./_site if git ls-remote --exit-code --heads origin gh-pages >/dev/null 2>&1; then tmp="$(mktemp -d)" git clone --depth 1 --branch gh-pages \ From 4cafbe3cedc2038d843842837109446ac62aeb1f Mon Sep 17 00:00:00 2001 From: Weiqiang Wu <598855847@qq.com> Date: Fri, 8 May 2026 13:02:57 +0800 Subject: [PATCH 29/41] Revert "fix delpoy (#256)" (#257) This reverts commit 74dae5fe44ec06895ce74cec74c620fe65de707e. --- .github/workflows/pages.yml | 9 --------- 1 file changed, 9 deletions(-) diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml index 6915323..8f54226 100644 --- a/.github/workflows/pages.yml +++ b/.github/workflows/pages.yml @@ -80,18 +80,9 @@ jobs: # auto-served, so we have to graft its `dev/` tree onto `_site/` # here. Missing branch is tolerated (fresh forks without any # benchmark run yet). - # - # NOTE on the `sudo chown` below: `actions/jekyll-build-pages` is - # a Docker action that runs as root inside a container, so - # `./_site` is created owned by root. This step runs on the host - # as the unprivileged `runner` user, which cannot otherwise write - # into `_site/`. Fix up ownership once before touching it; the - # upload-pages-artifact step that follows doesn't care about - # ownership, only about contents. - name: Merge benchmark results from gh-pages run: | set -euo pipefail - sudo chown -R "$(id -u):$(id -g)" ./_site if git ls-remote --exit-code --heads origin gh-pages >/dev/null 2>&1; then tmp="$(mktemp -d)" git clone --depth 1 --branch gh-pages \ From fc1f6fdcca1cb0b0d4aac40fba4c41971645be06 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 13:06:34 +0800 Subject: [PATCH 30/41] revert --- .github/workflows/pages.yml | 111 ------------------------------------ .gitignore | 8 --- _config.yml | 96 ------------------------------- athena/README.md | 7 --- doc/function.md | 8 --- index.md | 19 ------ 6 files changed, 249 deletions(-) delete mode 100644 .github/workflows/pages.yml delete mode 100644 _config.yml delete mode 100644 index.md diff --git a/.github/workflows/pages.yml b/.github/workflows/pages.yml deleted file mode 100644 index 8f54226..0000000 --- a/.github/workflows/pages.yml +++ /dev/null @@ -1,111 +0,0 @@ -# Publish the Jekyll site under the repo root to GitHub Pages. -# -# Split into build + deploy, per GitHub's recommended template, so: -# * Build runs in a generic runner, no Pages write permissions needed. -# * Deploy runs in the isolated `github-pages` environment that the -# repository's Pages settings protect. -# -# Pages source MUST be set to "GitHub Actions" (Settings → Pages → Build -# and deployment → Source). With the classic "Deploy from a branch" -# setting this workflow has no effect. -name: Pages - -on: - # Deploy is chained off the `Benchmark` workflow rather than listening - # to `push` directly. Rationale: - # * Benchmark already runs on every push to main, and it is the - # slower of the two pipelines. - # * Waiting for it to finish means the `dev/bench/` tree on the - # `gh-pages` branch is already refreshed by the time we graft it - # into `_site/`, so a single deploy per push is enough to publish - # BOTH the latest docs (README etc.) AND the latest benchmark. - # * A push that only touches docs still triggers benchmark.yml, so - # this chain fires regardless of what changed. The small cost is - # that pure-docs updates have to wait for the benchmark job. - # The `branches` filter + the `conclusion == success` gate below - # together ensure we only deploy for successful main-branch runs. - workflow_run: - workflows: ["Benchmark"] - types: [completed] - branches: [main] - # Allow manual redeploys from the Actions tab, handy for retrying a - # flaky remote-theme fetch without having to push an empty commit, - # and as an escape hatch if you want to republish without waiting for - # a benchmark run (e.g. README-only fix while benchmark is broken). - workflow_dispatch: - -# One in-flight deploy at a time; cancel older runs if a newer push -# supersedes them. This matches the GitHub template exactly and avoids -# a race where an older successful build overwrites a newer one. -concurrency: - group: pages - cancel-in-progress: true - -permissions: - contents: read - pages: write - id-token: write - -jobs: - build: - runs-on: ubuntu-latest - # For `workflow_run` triggers, only proceed if the upstream Benchmark - # run succeeded. Other triggers (push / workflow_dispatch) evaluate - # to `true` because `github.event.workflow_run` is null, which the - # `!=` comparison handles correctly. - if: ${{ github.event_name != 'workflow_run' || github.event.workflow_run.conclusion == 'success' }} - steps: - - name: Checkout - uses: actions/checkout@v4 - - - name: Setup Pages - # Emits `base_path` for downstream steps — we pass it through to - # the Jekyll builder so URLs render with the correct /JitFusion - # prefix on forks as well (a fork's Pages URL has a different - # repo-name segment, so hard-coding baseurl here would break it). - id: pages - uses: actions/configure-pages@v5 - - - name: Build with Jekyll - uses: actions/jekyll-build-pages@v1 - with: - source: ./ - destination: ./_site - - # Merge benchmark history published by `benchmark.yml` into the - # Jekyll output. The benchmark workflow keeps pushing new data to - # the `gh-pages` branch (under `dev/bench/`) via - # benchmark-action/github-action-benchmark; after we flipped the - # Pages source to "GitHub Actions", that branch is no longer - # auto-served, so we have to graft its `dev/` tree onto `_site/` - # here. Missing branch is tolerated (fresh forks without any - # benchmark run yet). - - name: Merge benchmark results from gh-pages - run: | - set -euo pipefail - if git ls-remote --exit-code --heads origin gh-pages >/dev/null 2>&1; then - tmp="$(mktemp -d)" - git clone --depth 1 --branch gh-pages \ - "https://github.com/${GITHUB_REPOSITORY}.git" "$tmp" - if [ -d "$tmp/dev" ]; then - mkdir -p ./_site/dev - cp -R "$tmp/dev/." ./_site/dev/ - fi - rm -rf "$tmp" - else - echo "gh-pages branch not found yet; skipping benchmark merge." - fi - - - name: Upload artifact - uses: actions/upload-pages-artifact@v3 - - deploy: - needs: build - runs-on: ubuntu-latest - environment: - name: github-pages - url: ${{ steps.deployment.outputs.page_url }} - steps: - - name: Deploy to GitHub Pages - id: deployment - uses: actions/deploy-pages@v4 diff --git a/.gitignore b/.gitignore index 8450ce8..db7390c 100644 --- a/.gitignore +++ b/.gitignore @@ -8,11 +8,3 @@ MODULE.bazel.lock /cmake-build* /out .bazelrc - -# Jekyll (GitHub Pages) — only relevant for local previews; CI builds -# happen in an ephemeral runner and never commit these back. -/_site -/.jekyll-cache -/.jekyll-metadata -/vendor -/Gemfile.lock \ No newline at end of file diff --git a/_config.yml b/_config.yml deleted file mode 100644 index 2206435..0000000 --- a/_config.yml +++ /dev/null @@ -1,96 +0,0 @@ -title: JitFusion -description: A high-performance execution engine based on LLVM JIT. -# Served from https://viktorika.github.io/JitFusion/ — the trailing -# slash matters: links rendered by Jekyll are resolved against this -# URL, so a missing baseurl would silently produce broken nav on -# GitHub Pages. -url: https://viktorika.github.io -baseurl: /JitFusion - -# --------------------------------------------------------------------------- -# Theme -# --------------------------------------------------------------------------- -# We use `just-the-docs` via `remote_theme` so the site does not need a -# Gemfile / bundler on the runner: GitHub Pages and `actions/jekyll-build-pages` -# both fetch the gem transparently. If you ever want local preview, do -# `bundle init && bundle add jekyll just-the-docs webrick` — neither is -# required in CI. -remote_theme: just-the-docs/just-the-docs - -# Enable the built-in client-side search bundled with just-the-docs. It -# indexes at build time into a JSON file, so there is no runtime cost or -# external service. -search_enabled: true -search: - heading_level: 3 - previews: 3 - -# Color scheme and top-right nav buttons. `Benchmarks` points into -# `dev/bench/`, which is NOT built by Jekyll — it is grafted onto -# `_site/` by the Pages workflow from the `gh-pages` branch, where -# benchmark-action/github-action-benchmark keeps publishing history -# from `benchmark.yml`. Using a site-relative link via `baseurl` keeps -# the button working on forks too (their Pages URL has a different -# repo-name segment). -color_scheme: light -aux_links: - "GitHub": - - "https://github.com/viktorika/JitFusion" - "Benchmarks": - - "{{ site.baseurl }}/dev/bench/" - -# --------------------------------------------------------------------------- -# What Jekyll should (and must not) process -# --------------------------------------------------------------------------- -# The repo root contains a lot of non-doc content that is either huge -# (generated parsers), meaningless on a web page (Bazel metadata), or -# actively harmful if Jekyll tries to render it as Liquid (C++ source -# with `{{` / `{%` sequences would crash the build). We list every such -# path here rather than relying on include-lists so that *adding* a new -# Markdown doc just works without editing this file. -exclude: - - BUILD - - MODULE.bazel - - WORKSPACE - - CMakeLists.txt - - LICENSE - - llvm_repository.bzl - - .bazelversion - - .clang-tidy - - .gitignore - - Gemfile - - Gemfile.lock - - vendor/ - - node_modules/ - - cmake-build/ - - build/ - - out/ - - bazel-bin/ - - bazel-out/ - - bazel-testlogs/ - - bazel-JitFusion/ - - src/ - - include/ - - test/ - - benchmark/ - - athena/ast_builder.cc - - athena/ast_builder.h - - athena/athena.cc - - athena/athena.h - - athena/dsu.cc - - athena/dsu.h - - athena/gen_parser.sh - - athena/location.hh - - athena/parser.cc - - athena/parser.hh - - athena/parser.yy - - athena/pipeline_grouper.cc - - athena/pipeline_grouper.h - - athena/token.cc - - athena/token.ll - - athena/test/ - -# Plugins available on GitHub Pages without a Gemfile. -plugins: - - jekyll-remote-theme - - jekyll-seo-tag diff --git a/athena/README.md b/athena/README.md index 30f99c2..2803b05 100644 --- a/athena/README.md +++ b/athena/README.md @@ -1,10 +1,3 @@ ---- -title: Athena DSL -nav_order: 2 -# Published under /JitFusion/athena/ — the URL keeps the directory -# layout so relative links from other pages stay stable. ---- - # athena An execution engine utilizing DSL in combination with jitfusion. diff --git a/doc/function.md b/doc/function.md index fc52afe..e65094b 100644 --- a/doc/function.md +++ b/doc/function.md @@ -1,11 +1,3 @@ ---- -title: Function Reference -nav_order: 3 -# This file is large (~1500 lines). just-the-docs renders it as a -# single long page with a right-hand TOC built from the `##` headings, -# which is exactly what we want for a function catalog. ---- - # function The following are the currently supported functions: diff --git a/index.md b/index.md deleted file mode 100644 index 67dff6b..0000000 --- a/index.md +++ /dev/null @@ -1,19 +0,0 @@ ---- -title: Home -layout: home -nav_order: 1 -# The site root. We deliberately do NOT duplicate the README's content -# into this file. Instead we pull it in at build time with -# `include_relative`, so this page always matches whatever is on the -# repo front page without manual sync. The trade-off is that Liquid -# tags inside the README (`{{ ... }}` / `{% ... %}`) would be -# interpreted — but the README contains neither today and we'd catch -# it instantly if one were added (Jekyll build fails loudly). -# -# Note: relative image paths inside the included README (e.g. -# `doc/exec_pipeline_example.png`) resolve against THIS file's -# location (the repo root), not against the README's location — -# which happens to be the same directory, so everything lines up. ---- - -{% include_relative README.md %} From 2504f11d56d8e3158a3683ac759ba8059c3618a4 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Fri, 8 May 2026 15:53:20 +0800 Subject: [PATCH 31/41] optimize FilterByBitmap --- src/function/list_comparison.cc | 66 +++++++++++++++------------------ 1 file changed, 29 insertions(+), 37 deletions(-) diff --git a/src/function/list_comparison.cc b/src/function/list_comparison.cc index 97c8e6d..4fc9d28 100644 --- a/src/function/list_comparison.cc +++ b/src/function/list_comparison.cc @@ -371,59 +371,51 @@ U8ListStruct GenBitmapList(ListType a, ListType b, void *exec_context) { return result; } -std::array, 256> filter_index_table; -int GenerateFilterIndexTable() { - for (int mask = 0; mask < 256; mask++) { - int idx = 0; - for (int j = 0; j < 8; j++) { - if ((mask & (1 << j)) != 0) { - filter_index_table[mask][idx++] = j; - } - } - for (; idx < 8; idx++) { - filter_index_table[mask][idx] = -1; - } - } - return 0; -} -auto gen_filter_index_table_ret = GenerateFilterIndexTable(); - template ListType FilterByBitmap(ListType a, U8ListStruct bitmap, uint32_t bits_cnt, void *exec_context) { + using T = typename ListType::CElementType; auto *exec_ctx = reinterpret_cast(exec_context); if ((a.len + 7) / 8 != bitmap.len) { exec_ctx->AddError("FilterByBitmap: bitmap len is not corresponding to list len"); return {nullptr, 0}; } ListType result; - result.data = reinterpret_cast( - exec_ctx->arena.Allocate(bits_cnt * sizeof(typename ListType::CElementType))); + result.data = reinterpret_cast(exec_ctx->arena.Allocate((bits_cnt + 1) * sizeof(T))); result.len = bits_cnt; + uint32_t cur = 0; uint32_t full_bytes = a.len / 8; - for (std::size_t i = 0; i < full_bytes; i++) { + for (uint32_t i = 0; i < full_bytes; i++) { uint8_t mask = bitmap.data[i]; - const auto &indices = filter_index_table[mask]; - for (auto idx : indices) { - if (-1 == idx) { - break; - } - result.data[cur++] = (a.data[(i * 8) + idx]); + if (mask == 0) { + continue; + } + if (mask == 0xFFU) { + std::memcpy(result.data + cur, a.data + (i * 8), 8 * sizeof(T)); + cur += 8; + continue; + } + const T *base = a.data + (i * 8); + for (uint32_t k = 0; k < 8; k++) { + uint32_t b = (mask >> k) & 1U; + result.data[cur] = base[k]; + cur += b; } } + if (full_bytes < bitmap.len) { uint8_t mask = bitmap.data[full_bytes]; - const auto &indices = filter_index_table[mask]; - for (auto idx : indices) { - if (-1 == idx) { - break; - } - uint32_t src_idx = (full_bytes * 8) + idx; - if (src_idx >= a.len) { - exec_ctx->AddError("FilterByBitmap: bitmap len is too long"); - return {nullptr, 0}; - } - result.data[cur++] = a.data[src_idx]; + uint32_t base_idx = full_bytes * 8; + uint32_t valid = a.len - base_idx; + if ((mask >> valid) != 0) { + exec_ctx->AddError("FilterByBitmap: bitmap len is too long"); + return {nullptr, 0}; + } + const T *base = a.data + base_idx; + for (uint32_t k = 0; k < valid; k++) { + uint32_t b = (mask >> k) & 1U; + result.data[cur] = base[k]; + cur += b; } } if (cur != bits_cnt) { From fc5135f4006387839804f7af48e9cca41835fb56 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Sat, 9 May 2026 14:38:52 +0800 Subject: [PATCH 32/41] Athena DSL support comment --- athena/test/comment_test.cc | 145 +++++++++++ athena/token.cc | 477 +++++++++++++++++++----------------- athena/token.ll | 8 + 3 files changed, 403 insertions(+), 227 deletions(-) create mode 100644 athena/test/comment_test.cc diff --git a/athena/test/comment_test.cc b/athena/test/comment_test.cc new file mode 100644 index 0000000..65ed4f8 --- /dev/null +++ b/athena/test/comment_test.cc @@ -0,0 +1,145 @@ +#include +#include "gtest/gtest.h" +#include "test_helper.h" + +using athena::AthenaExpression; +using athena::FunctionRegistry; +using athena::FunctionRegistryFactory; +using athena::RetType; + +namespace { + +std::unique_ptr MakeRegistry() { + std::unique_ptr reg; + EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(®).ok()); + return reg; +} + +} // namespace + +// 单行注释 // 在表达式末尾 +TEST(CommentTest, LineCommentAtEol) { + AthenaExpression athena; + auto reg = MakeRegistry(); + ASSERT_TRUE(athena.Compile("r = 42; // this is a trailing comment\n", reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 42); +} + +// 单行注释独占一行 +TEST(CommentTest, LineCommentWholeLine) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + // top-level comment + r = 1 + 2; + // another comment after + )"; + ASSERT_TRUE(athena.Compile(code, reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 3); +} + +// 块注释在表达式中间 +TEST(CommentTest, BlockCommentInline) { + AthenaExpression athena; + auto reg = MakeRegistry(); + ASSERT_TRUE(athena.Compile("r = 1 /* mid */ + 2;", reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 3); +} + +// 跨行块注释 +TEST(CommentTest, BlockCommentMultiline) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + /* this is + a multi line + comment */ + r = 10 * 2; + )"; + ASSERT_TRUE(athena.Compile(code, reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 20); +} + +// 块注释中包含 *、/ 不会提前结束 +TEST(CommentTest, BlockCommentWithStars) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + /***** banner *****/ + /* a / b * c ** d */ + r = 7; + )"; + ASSERT_TRUE(athena.Compile(code, reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 7); +} + +// 行注释里出现 /* 不会启动块注释 +TEST(CommentTest, LineCommentSwallowsBlockOpen) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + // this looks like /* but is just a line comment + r = 5; + )"; + ASSERT_TRUE(athena.Compile(code, reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 5); +} + +// 字符串字面量里的 //、/* 不应被当成注释 +TEST(CommentTest, StringLiteralIsNotComment) { + AthenaExpression athena; + auto reg = MakeRegistry(); + ASSERT_TRUE(athena.Compile(R"(r = "a // not comment /* still */ b";)", reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), "a // not comment /* still */ b"); +} + +// 多语句、混合注释 +TEST(CommentTest, MixedCommentsBetweenStatements) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + a = 1; // line + /* block */ b = 2; + c = a + b /* trailing */ ; + r = c; + )"; + ASSERT_TRUE(athena.Compile(code, reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 3); +} + +// 空块注释 /**/ +TEST(CommentTest, EmptyBlockComment) { + AthenaExpression athena; + auto reg = MakeRegistry(); + ASSERT_TRUE(athena.Compile("r = 1 /**/ + 2;", reg).ok()); + RetType ret; + ASSERT_TRUE(athena.Execute(nullptr, &ret).ok()); + EXPECT_EQ(std::get(ret), 3); +} + +// 仅含注释的代码应当报错（语法上仍需要一个赋值结果） +TEST(CommentTest, OnlyCommentFails) { + AthenaExpression athena; + auto reg = MakeRegistry(); + std::string code = R"( + // just a comment + /* nothing else */ + )"; + EXPECT_FALSE(athena.Compile(code, reg).ok()); +} diff --git a/athena/token.cc b/athena/token.cc index 8557088..7a9bd53 100644 --- a/athena/token.cc +++ b/athena/token.cc @@ -550,8 +550,8 @@ static void yynoreturn yy_fatal_error ( const char* msg , yyscan_t yyscanner ); yyg->yy_hold_char = *yy_cp; \ *yy_cp = '\0'; \ yyg->yy_c_buf_p = yy_cp; -#define YY_NUM_RULES 60 -#define YY_END_OF_BUFFER 61 +#define YY_NUM_RULES 62 +#define YY_END_OF_BUFFER 63 /* This struct is not used in this scanner, but its presence is necessary. */ struct yy_trans_info @@ -559,23 +559,24 @@ struct yy_trans_info flex_int32_t yy_verify; flex_int32_t yy_nxt; }; -static const flex_int16_t yy_accept[137] = +static const flex_int16_t yy_accept[143] = { 0, - 0, 0, 61, 60, 1, 2, 12, 60, 23, 26, - 60, 21, 22, 19, 18, 35, 17, 60, 20, 44, - 10, 31, 29, 33, 43, 36, 37, 25, 43, 43, - 43, 43, 43, 43, 43, 43, 43, 8, 24, 9, - 27, 1, 2, 30, 0, 58, 0, 13, 0, 59, - 0, 53, 53, 44, 0, 0, 0, 38, 32, 28, - 34, 39, 43, 43, 43, 43, 43, 43, 4, 11, - 43, 14, 43, 43, 43, 43, 14, 0, 53, 0, - 0, 0, 0, 0, 49, 0, 0, 0, 45, 13, - 43, 43, 43, 43, 43, 12, 43, 43, 43, 43, - - 0, 0, 56, 57, 50, 51, 52, 46, 47, 48, - 5, 6, 43, 43, 43, 43, 43, 15, 3, 54, - 55, 43, 43, 16, 43, 43, 43, 43, 42, 7, - 43, 43, 43, 41, 40, 0 + 0, 0, 63, 62, 1, 2, 14, 62, 25, 28, + 62, 23, 24, 21, 20, 37, 19, 62, 22, 46, + 12, 33, 31, 35, 45, 38, 39, 27, 45, 45, + 45, 45, 45, 45, 45, 45, 45, 10, 26, 11, + 29, 1, 2, 32, 0, 60, 0, 15, 0, 61, + 0, 55, 0, 3, 55, 46, 0, 0, 0, 40, + 34, 30, 36, 41, 45, 45, 45, 45, 45, 45, + 6, 13, 45, 16, 45, 45, 45, 45, 16, 0, + 0, 0, 3, 55, 0, 0, 0, 0, 0, 51, + 0, 0, 0, 47, 15, 45, 45, 45, 45, 45, + + 14, 45, 45, 45, 45, 0, 0, 4, 58, 59, + 52, 53, 54, 48, 49, 50, 7, 8, 45, 45, + 45, 45, 45, 17, 5, 56, 57, 45, 45, 18, + 45, 45, 45, 45, 44, 9, 45, 45, 45, 43, + 42, 0 } ; static const YY_CHAR yy_ec[256] = @@ -612,53 +613,55 @@ static const YY_CHAR yy_ec[256] = static const YY_CHAR yy_meta[57] = { 0, - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, - 1, 1, 1, 1, 2, 1, 3, 3, 3, 3, - 3, 3, 3, 1, 1, 1, 1, 4, 1, 1, - 1, 1, 4, 4, 4, 4, 4, 3, 4, 4, - 3, 4, 4, 4, 4, 4, 4, 4, 3, 4, - 4, 4, 1, 1, 1, 1 + 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 3, 1, 4, 4, 4, 4, + 4, 4, 4, 1, 1, 1, 1, 5, 1, 1, + 1, 1, 5, 5, 5, 5, 5, 4, 5, 5, + 4, 5, 5, 5, 5, 5, 5, 5, 4, 5, + 5, 5, 1, 1, 1, 1 } ; -static const flex_int16_t yy_base[141] = +static const flex_int16_t yy_base[149] = { 0, - 0, 0, 200, 201, 197, 195, 171, 52, 201, 189, - 50, 201, 201, 201, 201, 201, 201, 42, 201, 51, - 201, 42, 169, 44, 0, 201, 201, 201, 151, 30, - 159, 36, 148, 29, 141, 144, 149, 201, 134, 201, - 201, 185, 183, 201, 71, 201, 182, 201, 69, 201, - 181, 85, 92, 78, 63, 68, 102, 201, 201, 201, - 201, 201, 0, 147, 85, 134, 144, 138, 0, 0, - 131, 0, 130, 136, 127, 138, 201, 74, 116, 155, - 152, 150, 152, 149, 201, 147, 149, 146, 201, 0, - 115, 115, 105, 115, 102, 0, 103, 99, 109, 102, - - 125, 122, 201, 201, 201, 201, 201, 201, 201, 201, - 0, 0, 90, 108, 103, 82, 94, 0, 0, 201, - 201, 95, 86, 0, 70, 77, 64, 49, 0, 0, - 49, 36, 45, 0, 0, 201, 154, 158, 161, 162 + 0, 0, 217, 218, 214, 212, 188, 52, 218, 206, + 50, 218, 218, 218, 218, 218, 218, 42, 55, 52, + 218, 43, 186, 46, 0, 218, 218, 218, 168, 32, + 176, 38, 165, 38, 158, 161, 166, 218, 151, 218, + 218, 202, 200, 218, 72, 218, 199, 218, 70, 218, + 198, 86, 189, 0, 93, 79, 66, 103, 112, 218, + 218, 218, 218, 218, 0, 163, 38, 150, 160, 154, + 0, 0, 147, 0, 146, 152, 143, 154, 218, 69, + 179, 81, 0, 119, 170, 167, 165, 167, 164, 218, + 162, 164, 161, 218, 0, 140, 119, 109, 119, 106, + + 0, 107, 103, 113, 106, 129, 126, 218, 218, 218, + 218, 218, 218, 218, 218, 218, 0, 0, 94, 112, + 107, 94, 98, 0, 0, 218, 218, 96, 92, 0, + 74, 79, 84, 51, 0, 0, 52, 45, 56, 0, + 0, 218, 157, 162, 165, 166, 171, 176 } ; -static const flex_int16_t yy_def[141] = +static const flex_int16_t yy_def[149] = { 0, - 136, 1, 136, 136, 136, 136, 136, 137, 136, 136, - 138, 136, 136, 136, 136, 136, 136, 136, 136, 139, - 136, 136, 136, 136, 140, 136, 136, 136, 140, 140, - 140, 140, 140, 140, 140, 140, 140, 136, 136, 136, - 136, 136, 136, 136, 137, 136, 137, 136, 138, 136, - 138, 136, 136, 139, 136, 136, 136, 136, 136, 136, - 136, 136, 140, 140, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 140, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 140, - 140, 140, 140, 140, 140, 140, 140, 140, 140, 140, - - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 140, 140, 140, 140, 140, 140, 140, 140, 140, 136, - 136, 140, 140, 140, 140, 140, 140, 140, 140, 140, - 140, 140, 140, 140, 140, 0, 136, 136, 136, 136 + 142, 1, 142, 142, 142, 142, 142, 143, 142, 142, + 144, 142, 142, 142, 142, 142, 142, 142, 142, 145, + 142, 142, 142, 142, 146, 142, 142, 142, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 142, 142, 142, + 142, 142, 142, 142, 143, 142, 143, 142, 144, 142, + 144, 142, 147, 148, 142, 145, 142, 142, 142, 142, + 142, 142, 142, 142, 146, 146, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 142, 142, + 147, 147, 148, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 146, 146, 146, 146, 146, 146, + + 146, 146, 146, 146, 146, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 146, 146, 146, 146, + 146, 146, 146, 146, 146, 142, 142, 146, 146, 146, + 146, 146, 146, 146, 146, 146, 146, 146, 146, 146, + 146, 0, 142, 142, 142, 142, 142, 142 } ; -static const flex_int16_t yy_nxt[258] = +static const flex_int16_t yy_nxt[275] = { 0, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 20, 20, 20, @@ -666,31 +669,33 @@ static const flex_int16_t yy_nxt[258] = 27, 28, 4, 29, 25, 25, 30, 31, 25, 25, 32, 25, 33, 34, 25, 25, 35, 36, 25, 37, 25, 25, 38, 39, 40, 41, 46, 50, 52, 52, - 52, 52, 52, 52, 52, 53, 58, 59, 44, 61, - 62, 65, 66, 69, 72, 46, 50, 73, 70, 51, - 67, 47, 80, 135, 81, 82, 134, 83, 55, 84, - 85, 56, 53, 101, 133, 102, 132, 131, 51, 57, - - 47, 52, 52, 52, 52, 52, 52, 52, 79, 79, - 79, 79, 79, 79, 79, 55, 130, 129, 56, 86, - 128, 87, 78, 88, 89, 91, 57, 127, 126, 78, - 125, 92, 79, 79, 79, 79, 79, 79, 79, 124, - 123, 122, 121, 120, 119, 118, 117, 116, 115, 114, - 113, 112, 111, 78, 45, 45, 45, 45, 49, 49, - 49, 49, 54, 54, 63, 63, 110, 109, 108, 107, - 106, 105, 104, 103, 100, 99, 98, 97, 96, 95, - 94, 93, 90, 136, 136, 43, 42, 77, 76, 75, - 74, 71, 68, 64, 60, 48, 44, 43, 42, 136, - - 3, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136 + 52, 52, 52, 52, 52, 53, 55, 60, 61, 44, + 54, 63, 64, 67, 68, 71, 46, 50, 96, 51, + 72, 47, 69, 74, 97, 85, 75, 86, 106, 57, + 107, 82, 58, 55, 141, 140, 108, 139, 138, 51, + + 59, 47, 52, 52, 52, 52, 52, 52, 52, 84, + 84, 84, 84, 84, 84, 84, 57, 137, 136, 58, + 87, 135, 88, 80, 89, 90, 134, 59, 133, 91, + 80, 92, 132, 93, 94, 84, 84, 84, 84, 84, + 84, 84, 131, 130, 129, 128, 127, 126, 125, 124, + 123, 122, 121, 120, 119, 118, 80, 45, 45, 45, + 45, 45, 49, 49, 49, 49, 49, 56, 56, 65, + 65, 81, 81, 81, 81, 81, 83, 117, 83, 83, + 83, 116, 115, 114, 113, 112, 111, 110, 109, 82, + 105, 104, 103, 102, 101, 100, 99, 98, 95, 82, + + 142, 142, 43, 42, 79, 78, 77, 76, 73, 70, + 66, 62, 48, 44, 43, 42, 142, 3, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142 } ; -static const flex_int16_t yy_chk[258] = +static const flex_int16_t yy_chk[275] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, @@ -698,28 +703,30 @@ static const flex_int16_t yy_chk[258] = 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 8, 11, 18, 18, - 18, 18, 18, 18, 18, 20, 22, 22, 22, 24, - 24, 30, 30, 32, 34, 45, 49, 34, 32, 11, - 30, 8, 55, 133, 55, 56, 132, 56, 20, 56, - 56, 20, 54, 78, 131, 78, 128, 127, 49, 20, - - 45, 52, 52, 52, 52, 52, 52, 52, 53, 53, - 53, 53, 53, 53, 53, 54, 126, 125, 54, 57, - 123, 57, 52, 57, 57, 65, 54, 122, 117, 53, - 116, 65, 79, 79, 79, 79, 79, 79, 79, 115, - 114, 113, 102, 101, 100, 99, 98, 97, 95, 94, - 93, 92, 91, 79, 137, 137, 137, 137, 138, 138, - 138, 138, 139, 139, 140, 140, 88, 87, 86, 84, - 83, 82, 81, 80, 76, 75, 74, 73, 71, 68, - 67, 66, 64, 51, 47, 43, 42, 39, 37, 36, - 35, 33, 31, 29, 23, 10, 7, 6, 5, 3, - - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136, 136, 136, 136, - 136, 136, 136, 136, 136, 136, 136 + 18, 18, 18, 18, 18, 19, 20, 22, 22, 22, + 19, 24, 24, 30, 30, 32, 45, 49, 67, 11, + 32, 8, 30, 34, 67, 57, 34, 57, 80, 20, + 80, 82, 20, 56, 139, 138, 82, 137, 134, 49, + + 20, 45, 52, 52, 52, 52, 52, 52, 52, 55, + 55, 55, 55, 55, 55, 55, 56, 133, 132, 56, + 58, 131, 58, 52, 58, 58, 129, 56, 128, 59, + 55, 59, 123, 59, 59, 84, 84, 84, 84, 84, + 84, 84, 122, 121, 120, 119, 107, 106, 105, 104, + 103, 102, 100, 99, 98, 97, 84, 143, 143, 143, + 143, 143, 144, 144, 144, 144, 144, 145, 145, 146, + 146, 147, 147, 147, 147, 147, 148, 96, 148, 148, + 148, 93, 92, 91, 89, 88, 87, 86, 85, 81, + 78, 77, 76, 75, 73, 70, 69, 68, 66, 53, + + 51, 47, 43, 42, 39, 37, 36, 35, 33, 31, + 29, 23, 10, 7, 6, 5, 3, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142, 142, 142, 142, 142, 142, 142, + 142, 142, 142, 142 } ; /* The intent behind this definition is that it'll catch @@ -738,7 +745,7 @@ static const flex_int16_t yy_chk[258] = #include #include #include -#line 741 "token.cc" +#line 748 "token.cc" #line 15 "token.ll" #if defined __clang__ # define CLANG_VERSION (__clang_major__ * 100 + __clang_minor__) @@ -809,13 +816,13 @@ static const flex_int16_t yy_chk[258] = #if defined GCC_VERSION && 900 <= GCC_VERSION # pragma GCC diagnostic ignored "-Wuseless-cast" #endif -#line 812 "token.cc" +#line 819 "token.cc" #define YY_NO_INPUT 1 #line 94 "token.ll" // Code run each time a pattern is matched. # define YY_USER_ACTION loc.columns (yyleng); -#line 817 "token.cc" -#line 818 "token.cc" +#line 824 "token.cc" +#line 825 "token.cc" #define INITIAL 0 @@ -1082,7 +1089,7 @@ YY_DECL // Code run each time yylex is called. loc.step (); -#line 1085 "token.cc" +#line 1092 "token.cc" while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */ { @@ -1109,13 +1116,13 @@ YY_DECL while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 137 ) + if ( yy_current_state >= 143 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; ++yy_cp; } - while ( yy_current_state != 136 ); + while ( yy_current_state != 142 ); yy_cp = yyg->yy_last_accepting_cpos; yy_current_state = yyg->yy_last_accepting_state; @@ -1149,300 +1156,316 @@ loc.lines (yyleng); loc.step (); case 3: YY_RULE_SETUP #line 108 "token.ll" -return athena::Parser::make_WHEN (loc); +loc.step (); YY_BREAK case 4: +/* rule 4 can match eol */ YY_RULE_SETUP #line 109 "token.ll" -return athena::Parser::make_IF (loc); +{ + for (int i = 0; i < yyleng; ++i) { + if (yytext[i] == '\n') loc.lines(1); + } + loc.step(); + } YY_BREAK case 5: YY_RULE_SETUP -#line 110 "token.ll" -return athena::Parser::make_ELIF (loc); +#line 116 "token.ll" +return athena::Parser::make_WHEN (loc); YY_BREAK case 6: YY_RULE_SETUP -#line 111 "token.ll" -return athena::Parser::make_ELSE (loc); +#line 117 "token.ll" +return athena::Parser::make_IF (loc); YY_BREAK case 7: YY_RULE_SETUP -#line 112 "token.ll" -return athena::Parser::make_SWITCH (loc); +#line 118 "token.ll" +return athena::Parser::make_ELIF (loc); YY_BREAK case 8: YY_RULE_SETUP -#line 113 "token.ll" -return athena::Parser::make_LBRACE (loc); +#line 119 "token.ll" +return athena::Parser::make_ELSE (loc); YY_BREAK case 9: YY_RULE_SETUP -#line 114 "token.ll" -return athena::Parser::make_RBRACE (loc); +#line 120 "token.ll" +return athena::Parser::make_SWITCH (loc); YY_BREAK case 10: YY_RULE_SETUP -#line 115 "token.ll" -return athena::Parser::make_SEMI (loc); +#line 121 "token.ll" +return athena::Parser::make_LBRACE (loc); YY_BREAK case 11: YY_RULE_SETUP -#line 117 "token.ll" -return athena::Parser::make_IN (loc); +#line 122 "token.ll" +return athena::Parser::make_RBRACE (loc); YY_BREAK case 12: YY_RULE_SETUP -#line 118 "token.ll" -return athena::Parser::make_NOT (loc); +#line 123 "token.ll" +return athena::Parser::make_SEMI (loc); YY_BREAK case 13: YY_RULE_SETUP -#line 119 "token.ll" -return athena::Parser::make_AND (loc); +#line 125 "token.ll" +return athena::Parser::make_IN (loc); YY_BREAK case 14: YY_RULE_SETUP -#line 120 "token.ll" -return athena::Parser::make_OR (loc); +#line 126 "token.ll" +return athena::Parser::make_NOT (loc); YY_BREAK case 15: YY_RULE_SETUP -#line 121 "token.ll" -return athena::Parser::make_TRUE (loc); +#line 127 "token.ll" +return athena::Parser::make_AND (loc); YY_BREAK case 16: YY_RULE_SETUP -#line 122 "token.ll" -return athena::Parser::make_FALSE (loc); +#line 128 "token.ll" +return athena::Parser::make_OR (loc); YY_BREAK case 17: YY_RULE_SETUP -#line 123 "token.ll" -return athena::Parser::make_MINUS (loc); +#line 129 "token.ll" +return athena::Parser::make_TRUE (loc); YY_BREAK case 18: YY_RULE_SETUP -#line 124 "token.ll" -return athena::Parser::make_PLUS (loc); +#line 130 "token.ll" +return athena::Parser::make_FALSE (loc); YY_BREAK case 19: YY_RULE_SETUP -#line 125 "token.ll" -return athena::Parser::make_STAR (loc); +#line 131 "token.ll" +return athena::Parser::make_MINUS (loc); YY_BREAK case 20: YY_RULE_SETUP -#line 126 "token.ll" -return athena::Parser::make_SLASH (loc); +#line 132 "token.ll" +return athena::Parser::make_PLUS (loc); YY_BREAK case 21: YY_RULE_SETUP -#line 127 "token.ll" -return athena::Parser::make_LPAREN (loc); +#line 133 "token.ll" +return athena::Parser::make_STAR (loc); YY_BREAK case 22: YY_RULE_SETUP -#line 128 "token.ll" -return athena::Parser::make_RPAREN (loc); +#line 134 "token.ll" +return athena::Parser::make_SLASH (loc); YY_BREAK case 23: YY_RULE_SETUP -#line 129 "token.ll" -return athena::Parser::make_MODOLO (loc); +#line 135 "token.ll" +return athena::Parser::make_LPAREN (loc); YY_BREAK case 24: YY_RULE_SETUP -#line 130 "token.ll" -return athena::Parser::make_BITWISE_OR (loc); +#line 136 "token.ll" +return athena::Parser::make_RPAREN (loc); YY_BREAK case 25: YY_RULE_SETUP -#line 131 "token.ll" -return athena::Parser::make_BITWISE_XOR (loc); +#line 137 "token.ll" +return athena::Parser::make_MODOLO (loc); YY_BREAK case 26: YY_RULE_SETUP -#line 132 "token.ll" -return athena::Parser::make_BITWISE_AND (loc); +#line 138 "token.ll" +return athena::Parser::make_BITWISE_OR (loc); YY_BREAK case 27: YY_RULE_SETUP -#line 133 "token.ll" -return athena::Parser::make_BITWISE_NOT (loc); +#line 139 "token.ll" +return athena::Parser::make_BITWISE_XOR (loc); YY_BREAK case 28: YY_RULE_SETUP -#line 134 "token.ll" -return athena::Parser::make_EQUAL (loc); +#line 140 "token.ll" +return athena::Parser::make_BITWISE_AND (loc); YY_BREAK case 29: YY_RULE_SETUP -#line 135 "token.ll" -return athena::Parser::make_ASSIGNMENT (loc); +#line 141 "token.ll" +return athena::Parser::make_BITWISE_NOT (loc); YY_BREAK case 30: YY_RULE_SETUP -#line 136 "token.ll" -return athena::Parser::make_NOT_EQUAL (loc); +#line 142 "token.ll" +return athena::Parser::make_EQUAL (loc); YY_BREAK case 31: YY_RULE_SETUP -#line 137 "token.ll" -return athena::Parser::make_LESS_THAN (loc); +#line 143 "token.ll" +return athena::Parser::make_ASSIGNMENT (loc); YY_BREAK case 32: YY_RULE_SETUP -#line 138 "token.ll" -return athena::Parser::make_LESS_THAN_OR_EQUAL_TO (loc); +#line 144 "token.ll" +return athena::Parser::make_NOT_EQUAL (loc); YY_BREAK case 33: YY_RULE_SETUP -#line 139 "token.ll" -return athena::Parser::make_GREATER_THAN (loc); +#line 145 "token.ll" +return athena::Parser::make_LESS_THAN (loc); YY_BREAK case 34: YY_RULE_SETUP -#line 140 "token.ll" -return athena::Parser::make_GREATER_THAN_OR_EQUAL_TO (loc); +#line 146 "token.ll" +return athena::Parser::make_LESS_THAN_OR_EQUAL_TO (loc); YY_BREAK case 35: YY_RULE_SETUP -#line 141 "token.ll" -return athena::Parser::make_COMMA (loc); +#line 147 "token.ll" +return athena::Parser::make_GREATER_THAN (loc); YY_BREAK case 36: YY_RULE_SETUP -#line 142 "token.ll" -return athena::Parser::make_LBRACKET (loc); +#line 148 "token.ll" +return athena::Parser::make_GREATER_THAN_OR_EQUAL_TO (loc); YY_BREAK case 37: YY_RULE_SETUP -#line 143 "token.ll" -return athena::Parser::make_RBRACKET (loc); +#line 149 "token.ll" +return athena::Parser::make_COMMA (loc); YY_BREAK case 38: YY_RULE_SETUP -#line 144 "token.ll" -return athena::Parser::make_BITWISE_LEFT (loc); +#line 150 "token.ll" +return athena::Parser::make_LBRACKET (loc); YY_BREAK case 39: YY_RULE_SETUP -#line 145 "token.ll" -return athena::Parser::make_BITWISE_RIGHT (loc); +#line 151 "token.ll" +return athena::Parser::make_RBRACKET (loc); YY_BREAK case 40: YY_RULE_SETUP -#line 147 "token.ll" -return athena::Parser::make_ENTRY_ARG (loc); +#line 152 "token.ll" +return athena::Parser::make_BITWISE_LEFT (loc); YY_BREAK case 41: YY_RULE_SETUP -#line 148 "token.ll" -return athena::Parser::make_EXEC_CTX (loc); +#line 153 "token.ll" +return athena::Parser::make_BITWISE_RIGHT (loc); YY_BREAK case 42: YY_RULE_SETUP -#line 149 "token.ll" -return athena::Parser::make_OUTPUT (loc); +#line 155 "token.ll" +return athena::Parser::make_ENTRY_ARG (loc); YY_BREAK case 43: YY_RULE_SETUP -#line 151 "token.ll" -return athena::Parser::make_IDENTIFIER (std::string(yytext), loc); +#line 156 "token.ll" +return athena::Parser::make_EXEC_CTX (loc); YY_BREAK case 44: YY_RULE_SETUP -#line 153 "token.ll" -return athena::Parser::make_I32 (std::stoull(yytext), loc); +#line 157 "token.ll" +return athena::Parser::make_OUTPUT (loc); YY_BREAK case 45: YY_RULE_SETUP -#line 154 "token.ll" -return athena::Parser::make_U8 (std::stoull(yytext), loc); +#line 159 "token.ll" +return athena::Parser::make_IDENTIFIER (std::string(yytext), loc); YY_BREAK case 46: YY_RULE_SETUP -#line 155 "token.ll" -return athena::Parser::make_U16 (std::stoull(yytext), loc); +#line 161 "token.ll" +return athena::Parser::make_I32 (std::stoull(yytext), loc); YY_BREAK case 47: YY_RULE_SETUP -#line 156 "token.ll" -return athena::Parser::make_U32 (std::stoull(yytext), loc); +#line 162 "token.ll" +return athena::Parser::make_U8 (std::stoull(yytext), loc); YY_BREAK case 48: YY_RULE_SETUP -#line 157 "token.ll" -return athena::Parser::make_U64 (std::stoull(yytext), loc); +#line 163 "token.ll" +return athena::Parser::make_U16 (std::stoull(yytext), loc); YY_BREAK case 49: YY_RULE_SETUP -#line 158 "token.ll" -return athena::Parser::make_I8 (std::stoull(yytext), loc); +#line 164 "token.ll" +return athena::Parser::make_U32 (std::stoull(yytext), loc); YY_BREAK case 50: YY_RULE_SETUP -#line 159 "token.ll" -return athena::Parser::make_I16 (std::stoull(yytext), loc); +#line 165 "token.ll" +return athena::Parser::make_U64 (std::stoull(yytext), loc); YY_BREAK case 51: YY_RULE_SETUP -#line 160 "token.ll" -return athena::Parser::make_I32 (std::stoull(yytext), loc); +#line 166 "token.ll" +return athena::Parser::make_I8 (std::stoull(yytext), loc); YY_BREAK case 52: YY_RULE_SETUP -#line 161 "token.ll" -return athena::Parser::make_I64 (std::stoull(yytext), loc); +#line 167 "token.ll" +return athena::Parser::make_I16 (std::stoull(yytext), loc); YY_BREAK case 53: YY_RULE_SETUP -#line 163 "token.ll" -return athena::Parser::make_F64 (std::stod(yytext), loc); +#line 168 "token.ll" +return athena::Parser::make_I32 (std::stoull(yytext), loc); YY_BREAK case 54: YY_RULE_SETUP -#line 164 "token.ll" -return athena::Parser::make_F32 (std::stof(yytext), loc); +#line 169 "token.ll" +return athena::Parser::make_I64 (std::stoull(yytext), loc); YY_BREAK case 55: YY_RULE_SETUP -#line 165 "token.ll" +#line 171 "token.ll" return athena::Parser::make_F64 (std::stod(yytext), loc); YY_BREAK case 56: YY_RULE_SETUP -#line 166 "token.ll" +#line 172 "token.ll" return athena::Parser::make_F32 (std::stof(yytext), loc); YY_BREAK case 57: YY_RULE_SETUP -#line 167 "token.ll" +#line 173 "token.ll" return athena::Parser::make_F64 (std::stod(yytext), loc); YY_BREAK case 58: -/* rule 58 can match eol */ YY_RULE_SETUP -#line 170 "token.ll" -return athena::Parser::make_STRING (std::string(yytext + 1, yyleng - 2), loc); +#line 174 "token.ll" +return athena::Parser::make_F32 (std::stof(yytext), loc); YY_BREAK case 59: -/* rule 59 can match eol */ YY_RULE_SETUP -#line 171 "token.ll" +#line 175 "token.ll" +return athena::Parser::make_F64 (std::stod(yytext), loc); + YY_BREAK +case 60: +/* rule 60 can match eol */ +YY_RULE_SETUP +#line 178 "token.ll" +return athena::Parser::make_STRING (std::string(yytext + 1, yyleng - 2), loc); + YY_BREAK +case 61: +/* rule 61 can match eol */ +YY_RULE_SETUP +#line 179 "token.ll" return athena::Parser::make_STRING (std::string(yytext + 1, yyleng - 2), loc); YY_BREAK case YY_STATE_EOF(INITIAL): -#line 173 "token.ll" +#line 181 "token.ll" return athena::Parser::make_YYEOF (loc); YY_BREAK -case 60: +case 62: YY_RULE_SETUP -#line 174 "token.ll" +#line 182 "token.ll" ECHO; YY_BREAK -#line 1445 "token.cc" +#line 1468 "token.cc" case YY_END_OF_BUFFER: { @@ -1740,7 +1763,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 137 ) + if ( yy_current_state >= 143 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; @@ -1769,11 +1792,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner) while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state ) { yy_current_state = (int) yy_def[yy_current_state]; - if ( yy_current_state >= 137 ) + if ( yy_current_state >= 143 ) yy_c = yy_meta[yy_c]; } yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c]; - yy_is_jam = (yy_current_state == 136); + yy_is_jam = (yy_current_state == 142); (void)yyg; return yy_is_jam ? 0 : yy_current_state; @@ -2572,7 +2595,7 @@ void yyfree (void * ptr , yyscan_t yyscanner) #define YYTABLES_NAME "yytables" -#line 174 "token.ll" +#line 182 "token.ll" jitfusion::Status athena::ProgramAstBuilder::Scan(const std::string &code) { diff --git a/athena/token.ll b/athena/token.ll index a63529b..777a285 100644 --- a/athena/token.ll +++ b/athena/token.ll @@ -104,6 +104,14 @@ blank [ \t\r] {blank}+ loc.step (); \n+ loc.lines (yyleng); loc.step (); +"//"[^\n]* loc.step (); +"/*"([^*]|\*+[^*/])*\*+"/" { + for (int i = 0; i < yyleng; ++i) { + if (yytext[i] == '\n') loc.lines(1); + } + loc.step(); + } + "when" return athena::Parser::make_WHEN (loc); "if" return athena::Parser::make_IF (loc); "elif" return athena::Parser::make_ELIF (loc); From 667336d93033ccfcc31a3aabd4d5b16d51a98506 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Sat, 9 May 2026 14:43:59 +0800 Subject: [PATCH 33/41] add sign --- athena/test/comment_test.cc | 6 ++++++ athena/test/const_value_test.cc | 6 ++++++ athena/test/control_flow_test.cc | 6 ++++++ athena/test/cse_test.cc | 6 ++++++ athena/test/exec_error_test.cc | 6 ++++++ athena/test/function_test.cc | 6 ++++++ athena/test/list_function_test.cc | 6 ++++++ athena/test/logical_op_test.cc | 6 ++++++ athena/test/operator_test.cc | 6 ++++++ athena/test/pipeline_grouper_test.cc | 10 ++++++---- athena/test/pipeline_test.cc | 6 ++++++ athena/test/ref_node_test.cc | 6 ++++++ athena/test/string_function_test.cc | 6 ++++++ athena/test/test_helper.h | 6 ++++++ athena/test/when_test.cc | 6 ++++++ src/exec_engine.cc | 2 +- src/function/list_indexing.cc | 2 +- 17 files changed, 92 insertions(+), 6 deletions(-) diff --git a/athena/test/comment_test.cc b/athena/test/comment_test.cc index 65ed4f8..0042d83 100644 --- a/athena/test/comment_test.cc +++ b/athena/test/comment_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:39:08 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:39:08 + */ #include #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/const_value_test.cc b/athena/test/const_value_test.cc index f11961e..082dd64 100644 --- a/athena/test/const_value_test.cc +++ b/athena/test/const_value_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/control_flow_test.cc b/athena/test/control_flow_test.cc index 247d121..9eefa7d 100644 --- a/athena/test/control_flow_test.cc +++ b/athena/test/control_flow_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/cse_test.cc b/athena/test/cse_test.cc index 55da3e8..046d2f9 100644 --- a/athena/test/cse_test.cc +++ b/athena/test/cse_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/exec_error_test.cc b/athena/test/exec_error_test.cc index ff9af00..fb584ae 100644 --- a/athena/test/exec_error_test.cc +++ b/athena/test/exec_error_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/function_test.cc b/athena/test/function_test.cc index 9f43cd4..b283cc4 100644 --- a/athena/test/function_test.cc +++ b/athena/test/function_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/list_function_test.cc b/athena/test/list_function_test.cc index d945a37..1650fca 100644 --- a/athena/test/list_function_test.cc +++ b/athena/test/list_function_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/logical_op_test.cc b/athena/test/logical_op_test.cc index c2b7687..eb6fd70 100644 --- a/athena/test/logical_op_test.cc +++ b/athena/test/logical_op_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/operator_test.cc b/athena/test/operator_test.cc index 76f6987..fa73f6c 100644 --- a/athena/test/operator_test.cc +++ b/athena/test/operator_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/pipeline_grouper_test.cc b/athena/test/pipeline_grouper_test.cc index daab98a..107c989 100644 --- a/athena/test/pipeline_grouper_test.cc +++ b/athena/test/pipeline_grouper_test.cc @@ -1,15 +1,17 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:43:06 + */ #include "pipeline_grouper.h" #include "ast_builder.h" #include "gtest/gtest.h" #include "test_helper.h" -using athena::FunctionRegistry; -using athena::FunctionRegistryFactory; -using athena::FunctionSignature; using athena::PipelineGrouper; using athena::ProgramAstBuilder; -using athena::ValueType; using jitfusion::ExecNode; using jitfusion::NoOPNode; diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index c95cff4..2ae1614 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/ref_node_test.cc b/athena/test/ref_node_test.cc index 8e1fb7c..8009d68 100644 --- a/athena/test/ref_node_test.cc +++ b/athena/test/ref_node_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/string_function_test.cc b/athena/test/string_function_test.cc index 7442400..91236cb 100644 --- a/athena/test/string_function_test.cc +++ b/athena/test/string_function_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include "gtest/gtest.h" #include "test_helper.h" diff --git a/athena/test/test_helper.h b/athena/test/test_helper.h index bf72a91..f903402 100644 --- a/athena/test/test_helper.h +++ b/athena/test/test_helper.h @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #pragma once #include diff --git a/athena/test/when_test.cc b/athena/test/when_test.cc index 259abe2..f602e1d 100644 --- a/athena/test/when_test.cc +++ b/athena/test/when_test.cc @@ -1,3 +1,9 @@ +/* + * @Author: victorika + * @Date: 2026-05-09 14:40:12 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:40:12 + */ #include #include "gtest/gtest.h" diff --git a/src/exec_engine.cc b/src/exec_engine.cc index d5ff70b..0a918b9 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 10:59:33 * @Last Modified by: victorika - * @Last Modified time: 2026-05-07 18:00:00 + * @Last Modified time: 2026-05-09 14:42:00 */ #include "exec_engine.h" diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index 1fb9e74..c8d3bbe 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:15:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-06 11:15:00 + * @Last Modified time: 2026-05-09 14:41:06 */ #include #include From 9528f179f50ac8cde11ee627e6566c1d75d14733 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Sat, 9 May 2026 14:47:22 +0800 Subject: [PATCH 34/41] update readme --- athena/README.md | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/athena/README.md b/athena/README.md index 2803b05..20b659f 100644 --- a/athena/README.md +++ b/athena/README.md @@ -40,6 +40,24 @@ Note: Variables modified inside `when` branches must maintain the same type as t * 5.You can obtain the input parameter pointer through the entry_arg name, access the ExecContext via exec_ctx and obtain the output parameter pointer through the output name. +* 6.Comments are supported in two C/C++ styles: + * Line comments start with `//` and extend to the end of the line. + * Block comments are wrapped in `/* ... */` and may span multiple lines. + + Comments are stripped during lexing and have no effect on AST, type checking + or codegen. They are also ignored inside string literals (i.e., `//` and + `/*` appearing inside `"..."` / `'...'` are treated as plain characters). + + Example: + + ``` + // a leading comment + a = 1 /* inline */ + 2; // trailing comment + /* a multi- + line comment */ + r = a; + ``` + ## Execute Funtion `AthenaExpression` — expression mode: From ee383a401a6140e90ac2e5611aea0734c37c4bbc Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Sat, 9 May 2026 14:48:48 +0800 Subject: [PATCH 35/41] remove useless comment --- athena/test/comment_test.cc | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/athena/test/comment_test.cc b/athena/test/comment_test.cc index 0042d83..15697c6 100644 --- a/athena/test/comment_test.cc +++ b/athena/test/comment_test.cc @@ -1,8 +1,8 @@ /* * @Author: victorika * @Date: 2026-05-09 14:39:08 - * @Last Modified by: victorika - * @Last Modified time: 2026-05-09 14:39:08 + * @Last Modified by: victorika + * @Last Modified time: 2026-05-09 14:45:12 */ #include #include "gtest/gtest.h" @@ -23,7 +23,6 @@ std::unique_ptr MakeRegistry() { } // namespace -// 单行注释 // 在表达式末尾 TEST(CommentTest, LineCommentAtEol) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -33,7 +32,6 @@ TEST(CommentTest, LineCommentAtEol) { EXPECT_EQ(std::get(ret), 42); } -// 单行注释独占一行 TEST(CommentTest, LineCommentWholeLine) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -48,7 +46,6 @@ TEST(CommentTest, LineCommentWholeLine) { EXPECT_EQ(std::get(ret), 3); } -// 块注释在表达式中间 TEST(CommentTest, BlockCommentInline) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -58,7 +55,6 @@ TEST(CommentTest, BlockCommentInline) { EXPECT_EQ(std::get(ret), 3); } -// 跨行块注释 TEST(CommentTest, BlockCommentMultiline) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -74,7 +70,6 @@ TEST(CommentTest, BlockCommentMultiline) { EXPECT_EQ(std::get(ret), 20); } -// 块注释中包含 *、/ 不会提前结束 TEST(CommentTest, BlockCommentWithStars) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -89,7 +84,6 @@ TEST(CommentTest, BlockCommentWithStars) { EXPECT_EQ(std::get(ret), 7); } -// 行注释里出现 /* 不会启动块注释 TEST(CommentTest, LineCommentSwallowsBlockOpen) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -103,7 +97,6 @@ TEST(CommentTest, LineCommentSwallowsBlockOpen) { EXPECT_EQ(std::get(ret), 5); } -// 字符串字面量里的 //、/* 不应被当成注释 TEST(CommentTest, StringLiteralIsNotComment) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -113,7 +106,6 @@ TEST(CommentTest, StringLiteralIsNotComment) { EXPECT_EQ(std::get(ret), "a // not comment /* still */ b"); } -// 多语句、混合注释 TEST(CommentTest, MixedCommentsBetweenStatements) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -129,7 +121,6 @@ TEST(CommentTest, MixedCommentsBetweenStatements) { EXPECT_EQ(std::get(ret), 3); } -// 空块注释 /**/ TEST(CommentTest, EmptyBlockComment) { AthenaExpression athena; auto reg = MakeRegistry(); @@ -139,7 +130,6 @@ TEST(CommentTest, EmptyBlockComment) { EXPECT_EQ(std::get(ret), 3); } -// 仅含注释的代码应当报错（语法上仍需要一个赋值结果） TEST(CommentTest, OnlyCommentFails) { AthenaExpression athena; auto reg = MakeRegistry(); From 678a48a28ea25ec45b5a743b9836271d1aab26f2 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Sat, 9 May 2026 15:00:40 +0800 Subject: [PATCH 36/41] update version to 1.3.0 --- CMakeLists.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index f96a935..174b7a5 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 3.10) -project(jitfusion VERSION 1.2.1 LANGUAGES CXX) +project(jitfusion VERSION 1.3.0 LANGUAGES CXX) # GNUInstallDirs defines CMAKE_INSTALL_{LIBDIR,INCLUDEDIR,BINDIR,DOCDIR,...} # so we need it before any target_include_directories(... $ ...) From 21050a67441730af83819a1b13085751fca9caab Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Mon, 11 May 2026 14:57:57 +0800 Subject: [PATCH 37/41] optimize ListLookupIndex --- athena/test/cse_test.cc | 140 ++++++++++++++++++++- include/arena.h | 80 +++++++++++- src/arena.cc | 18 +++ src/function/list_indexing.cc | 226 ++++++++++++++++++++++++---------- test/arena_test.cc | 128 +++++++++++++++++++ 5 files changed, 527 insertions(+), 65 deletions(-) diff --git a/athena/test/cse_test.cc b/athena/test/cse_test.cc index 046d2f9..b0ddd3d 100644 --- a/athena/test/cse_test.cc +++ b/athena/test/cse_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-09 14:40:12 * @Last Modified by: victorika - * @Last Modified time: 2026-05-09 14:40:12 + * @Last Modified time: 2026-05-11 14:55:10 */ #include "gtest/gtest.h" #include "test_helper.h" @@ -436,3 +436,141 @@ TEST(CSETest, ComplexPipelineCSE) { EXPECT_EQ(data.compute_count, 1); EXPECT_EQ(data.transform_count, 1); } + +// ----------------------------------------------------------------------------- +// CSE for readonly C functions whose return type is kPtr. +// +// The split-kernel design of ListLookupIndex relies on LLVM EarlyCSE/GVN +// merging two same-arg calls of a readonly ptr-returning function (the +// hash-table builder) into one. The tests below pin that behavior down +// at the Athena DSL layer with a runtime call counter — the same pattern +// the CSETests above use for scalar-returning functions. +// ----------------------------------------------------------------------------- + +namespace { + +// Per-pipeline state that doubles as both the entry-arg payload and the +// scratch space the make_ptr helper returns a pointer into. Keeping the +// pointer stable across invocations means use_ptr never has to worry +// about memory ownership; the only side effect we care about is the +// monotonically-increasing call counter. +struct PtrCSETestData { + int32_t storage{0}; + int32_t make_ptr_count{0}; + int32_t use_ptr_count{0}; +}; + +// Stand-in for BuildHashTable: returns a stable pointer (so that two +// merged calls would observe identical results) and bumps a per-call +// counter so the test can assert how many times the function actually +// ran. The "seed" parameter is what we expect LLVM CSE to key off of. +void* CountedMakePtr(void* entry_arguments, int32_t seed) { + auto* data = reinterpret_cast(entry_arguments); + data->make_ptr_count++; + data->storage = seed; + return &data->storage; +} + +// Stand-in for LookupHashTable: dereferences the table and adds k. Two +// calls with different k must NOT be merged. +int32_t CountedUsePtr(void* entry_arguments, void* p, int32_t k) { + auto* data = reinterpret_cast(entry_arguments); + data->use_ptr_count++; + return *reinterpret_cast(p) + k; +} + +void StoreI32(void* output, int32_t index, int32_t value) { reinterpret_cast(output)[index] = value; } + +} // namespace + +TEST(CSETest, ReadOnlyPtrReturningFunctionMerge) { + // Two use_ptr() calls feed off make_ptr(entry_arg, 7) with identical + // arguments. Because make_ptr is registered readonly+nounwind, LLVM + // EarlyCSE/GVN must merge the two make_ptr calls into one; the two + // use_ptr calls take different k and stay separate. The counter assertions + // below are the source of truth — IR text would be brittle across LLVM + // upgrades. + AthenaPipeline athena; + std::unique_ptr func_registry; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + { + FunctionSignature sign("make_ptr", {ValueType::kPtr, ValueType::kI32}, ValueType::kPtr); + ASSERT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CountedMakePtr)).ok()); + } + { + FunctionSignature sign("use_ptr", {ValueType::kPtr, ValueType::kPtr, ValueType::kI32}, ValueType::kI32); + ASSERT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CountedUsePtr)).ok()); + } + { + FunctionSignature sign("store_i32", {ValueType::kPtr, ValueType::kI32, ValueType::kI32}, ValueType::kVoid); + ASSERT_TRUE(func_registry->RegisterStoreCFunc(sign, reinterpret_cast(StoreI32), 1).ok()); + } + + // result = use_ptr(make_ptr(entry, 7), 10) + use_ptr(make_ptr(entry, 7), 20) + // Expected result: (7 + 10) + (7 + 20) = 44 + std::string code = R"( + p1 = make_ptr(entry_arg, 7); + p2 = make_ptr(entry_arg, 7); + v1 = use_ptr(entry_arg, p1, 10); + v2 = use_ptr(entry_arg, p2, 20); + store_i32(output, 0, v1 + v2); + )"; + + std::vector codes = {code}; + ASSERT_TRUE(athena.Compile(codes, func_registry).ok()); + + PtrCSETestData data{}; + std::vector output(1, 0); + ASSERT_TRUE(athena.Execute(&data, output.data()).ok()); + + EXPECT_EQ(output[0], 44); + + // Core assertion: same-arg readonly calls returning kPtr collapse to + // a single runtime invocation. + EXPECT_EQ(data.make_ptr_count, 1) << "two same-arg make_ptr calls must be merged by LLVM CSE"; + // Differing k keeps the two use_ptr probes distinct. + EXPECT_EQ(data.use_ptr_count, 2) << "different-arg use_ptr calls must remain separate"; +} + +TEST(CSETest, ReadOnlyPtrReturningFunctionDifferentArgsNoMerge) { + // Same shape as above, but make_ptr now takes a different seed each time. + // CSE must NOT merge — we want each seed to flow through. + AthenaPipeline athena; + std::unique_ptr func_registry; + ASSERT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); + { + FunctionSignature sign("make_ptr", {ValueType::kPtr, ValueType::kI32}, ValueType::kPtr); + ASSERT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CountedMakePtr)).ok()); + } + { + FunctionSignature sign("use_ptr", {ValueType::kPtr, ValueType::kPtr, ValueType::kI32}, ValueType::kI32); + ASSERT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CountedUsePtr)).ok()); + } + { + FunctionSignature sign("store_i32", {ValueType::kPtr, ValueType::kI32, ValueType::kI32}, ValueType::kVoid); + ASSERT_TRUE(func_registry->RegisterStoreCFunc(sign, reinterpret_cast(StoreI32), 1).ok()); + } + + std::string code = R"( + p1 = make_ptr(entry_arg, 1); + p2 = make_ptr(entry_arg, 2); + v1 = use_ptr(entry_arg, p1, 10); + v2 = use_ptr(entry_arg, p2, 20); + store_i32(output, 0, v1 + v2); + )"; + + std::vector codes = {code}; + ASSERT_TRUE(athena.Compile(codes, func_registry).ok()); + + PtrCSETestData data{}; + std::vector output(1, 0); + ASSERT_TRUE(athena.Execute(&data, output.data()).ok()); + + // Note: because both calls return &data.storage, the second make_ptr + // overwrites storage to its seed before use_ptr reads it, so v1 actually + // sees the *second* seed by the time it dereferences. Whether that + // happens depends on the order LLVM schedules the calls; but for the + // sake of asserting "no merge" we only care about the counter. + EXPECT_EQ(data.make_ptr_count, 2) << "different-seed make_ptr calls must NOT be merged"; + EXPECT_EQ(data.use_ptr_count, 2); +} diff --git a/include/arena.h b/include/arena.h index 785a9e0..3fb7da6 100644 --- a/include/arena.h +++ b/include/arena.h @@ -2,12 +2,15 @@ * @Author: victorika * @Date: 2025-01-20 14:29:26 * @Last Modified by: victorika - * @Last Modified time: 2025-01-20 14:39:51 + * @Last Modified time: 2026-05-11 14:56:47 */ #pragma once #include #include +#include +#include +#include #include #include "status.h" @@ -22,6 +25,14 @@ namespace jitfusion { /// The allocated memory gets released only when the arena is destroyed, or on /// Reset. /// +/// In addition to raw byte allocation, Arena can also construct typed objects +/// via Create(...). Non-trivially-destructible objects so created have +/// their destructors run automatically on Reset() / ~Arena() (in reverse +/// construction order, mirroring C++ stack semantics). This lets callers +/// place objects holding heap-allocated state — std::unordered_map, +/// std::vector, std::string, etc. — directly on the arena without leaking +/// the heap allocations those objects internally own. +/// /// This code is not multi-thread safe, and avoids all locking for efficiency. /// class Arena { @@ -32,7 +43,10 @@ class Arena { static constexpr size_t kDefaultAlignment = 8; explicit Arena(size_t min_chunk_size = 4096) : min_chunk_size_(min_chunk_size) {}; - ~Arena() { ReleaseChunks(false); } + ~Arena() { + RunFinalizers(); + ReleaseChunks(false); + } // Allocate buffer of requested size with the given alignment. // `size == 0` is a valid no-op and returns nullptr; callers treating an // empty buffer (empty list/string) as legal data rely on this. The @@ -42,6 +56,41 @@ class Arena { // generated by LLVM's auto-vectorizer on list payloads. uint8_t* Allocate(size_t size, size_t alignment = kDefaultAlignment); + // Construct a `T` in arena-owned storage and return a pointer to it. + // + // Storage for the object itself is bump-allocated from the arena (so the + // object survives until the next Reset() / ~Arena), and — if T has a + // non-trivial destructor — a finalizer record is pushed onto an internal + // vector so that ~T() runs when the arena is reset or destroyed. + // + // Destruction order is the reverse of construction order, matching C++ + // stack semantics. This matters when later-constructed objects observe + // earlier-constructed ones (e.g. an object holding a non-owning pointer + // into another arena-resident object): ~T() of the later object runs + // first, while the earlier object is still alive. + // + // Returns nullptr if the underlying chunk allocation for T's storage + // fails. The finalizer vector itself uses heap allocation; if that + // allocation throws std::bad_alloc, the exception propagates out (this + // is the standard library's reporting channel for OOM in vector growth + // and matches how every other heap-backed container in the codebase + // behaves). + // + // Trivial-destructor types skip the finalizer record entirely — there is + // zero per-call overhead beyond the bump allocation. + template + T* Create(Args&&... args) { + void* mem = Allocate(sizeof(T), alignof(T)); + if (mem == nullptr) { + return nullptr; + } + T* obj = ::new (mem) T(std::forward(args)...); + if constexpr (!std::is_trivially_destructible_v) { + finalizers_.emplace_back(obj, &DestroyImpl); + } + return obj; + } + // Reset arena state. void Reset(); @@ -59,6 +108,19 @@ class Arena { size_t size_; }; + // Type-erased finalizer record. Stored in a vector so destruction can + // walk it in reverse for LIFO order, mirroring C++ stack semantics. + // The vector's heap buffer survives across Reset() (clear() preserves + // capacity), so steady-state Execute calls register finalizers without + // triggering further heap traffic once the working set is reached. + using FinalizerFn = void (*)(void*) noexcept; + struct Finalizer { + Finalizer() = default; + Finalizer(void* obj, FinalizerFn fn) : obj(obj), fn(fn) {} + void* obj; + FinalizerFn fn; + }; + static Status Allocate(uint8_t** buf, size_t size); static void Free(uint8_t* buf); @@ -69,6 +131,16 @@ class Arena { // release memory from buffers. void ReleaseChunks(bool retain_first); + // Walk the finalizer vector in reverse and invoke each ~T(), then + // clear() the vector. clear() preserves capacity so the next batch of + // registrations reuses the buffer. + void RunFinalizers() noexcept; + + template + static void DestroyImpl(void* p) noexcept { + static_cast(p)->~T(); + } + // The chunk-size used for allocations from system. size_t min_chunk_size_; @@ -83,6 +155,10 @@ class Arena { // List of allocated chunks. std::vector chunks_; + + // Finalizer records in registration order. Walked in reverse on + // RunFinalizers() to produce LIFO destruction. + std::vector finalizers_; }; } // namespace jitfusion \ No newline at end of file diff --git a/src/arena.cc b/src/arena.cc index b970c3f..8bfefa0 100644 --- a/src/arena.cc +++ b/src/arena.cc @@ -112,6 +112,12 @@ void Arena::Reset() { return; } + // Run finalizers BEFORE we reclaim / reuse chunks. The finalizer nodes + // and the objects they reference all live inside the chunks we are + // about to either free or recycle, so once chunks are reset the bytes + // backing those records are logically gone and must not be revisited. + RunFinalizers(); + // Release all but the first chunk. if (chunks_.size() > 1) { ReleaseChunks(true); @@ -133,4 +139,16 @@ void Arena::ReleaseChunks(bool retain_first) { } } +void Arena::RunFinalizers() noexcept { + // Reverse walk: most recently registered finalizer runs first (LIFO), + // matching C++ stack-unwinding semantics. clear() at the end preserves + // the vector's capacity so subsequent Reset/Execute cycles register + // their finalizers without further heap traffic once the steady-state + // count is reached. + for (auto it = finalizers_.rbegin(); it != finalizers_.rend(); ++it) { + it->fn(it->obj); + } + finalizers_.clear(); +} + } // namespace jitfusion \ No newline at end of file diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index c8d3bbe..8c7fbd5 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:15:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-09 14:41:06 + * @Last Modified time: 2026-05-11 14:55:04 */ #include #include @@ -24,25 +24,108 @@ namespace { constexpr uint32_t kLookupMiss = std::numeric_limits::max(); template -U32ListStruct ListLookupIndex(KList a, KList b, void *exec_context) { +using IntLookupTable = std::unordered_map; +using StringLookupTable = std::unordered_map; + +template +void *BuildLookupTableInt(KList b, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + IntLookupTable seed; + seed.reserve(static_cast(b.len) * 2); + for (uint32_t j = 0; j < b.len; ++j) { + seed.try_emplace(b.data[j], j); + } + return exec_ctx->arena.Create>(std::move(seed)); +} + +void *BuildLookupTableString(StringListStruct b, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + StringLookupTable seed; + seed.reserve(static_cast(b.len) * 2); + for (uint32_t j = 0; j < b.len; ++j) { + std::string_view sv(b.data[j].data, b.data[j].len); + seed.try_emplace(sv, j); + } + return exec_ctx->arena.Create(std::move(seed)); +} + +template +U32ListStruct LookupTableInt(KList a, void *table_ptr, void *exec_context) { auto *exec_ctx = reinterpret_cast(exec_context); + const auto *table = reinterpret_cast *>(table_ptr); + U32ListStruct result; result.len = a.len; result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * a.len)); - - std::unordered_map table; - table.reserve(static_cast(b.len) * 2); - for (uint32_t j = 0; j < b.len; ++j) { - table.try_emplace(b.data[j], j); + for (uint32_t i = 0; i < a.len; ++i) { + auto it = table->find(a.data[i]); + result.data[i] = (it == table->end()) ? kLookupMiss : it->second; } + return result; +} +U32ListStruct LookupTableString(StringListStruct a, void *table_ptr, void *exec_context) { + auto *exec_ctx = reinterpret_cast(exec_context); + const auto *table = reinterpret_cast(table_ptr); + + U32ListStruct result; + result.len = a.len; + result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * a.len)); for (uint32_t i = 0; i < a.len; ++i) { - auto it = table.find(a.data[i]); - result.data[i] = (it == table.end()) ? kLookupMiss : it->second; + std::string_view sv(a.data[i].data, a.data[i].len); + auto it = table->find(sv); + result.data[i] = (it == table->end()) ? kLookupMiss : it->second; } return result; } +// Internal symbol names exposed on FunctionRegistry. They are not meant +// to be invoked directly from user expressions (the user-facing API is +// `ListLookupIndex`); the lowering function below references them via +// these exact names, and `MappingToJIT` resolves the names to the C +// pointers registered alongside. +constexpr const char *kBuildIntName = "__BuildLookupTableInt"; +constexpr const char *kBuildStringName = "__BuildLookupTableString"; +constexpr const char *kLookupIntName = "__LookupTableInt"; +constexpr const char *kLookupStringName = "__LookupTableString"; + +bool IsStringListType(ValueType v) { return v == ValueType::kStringList; } + +// Lowering for the user-facing ListLookupIndex(a, b, ctx). Emits two +// readonly C calls - one to build the hash table over `b`, one to probe +// the table with `a`. LLVM CSE merges the BuildLookupTable_* call across +// multiple ListLookupIndex sites that share the same `b`. +llvm::Value *CodegenListLookupIndex(const FunctionSignature &sign, const std::vector &arg_types, + const std::vector &args, IRCodeGenContext &ctx) { + // sign.GetParamTypes() = {KList, KList, kPtr}; args[0]=a, args[1]=b, args[2]=exec_ctx + const auto ¶m_types = sign.GetParamTypes(); + const ValueType list_vt = param_types[0]; + const bool is_string = IsStringListType(list_vt); + const char *build_name = is_string ? kBuildStringName : kBuildIntName; + const char *lookup_name = is_string ? kLookupStringName : kLookupIntName; + + // Each helper has its own *registered* signature (so MappingToJIT and + // SetCFuncAttr can find them). Mirror those signatures here when + // asking the module for the function declaration. + FunctionSignature build_sign(build_name, {list_vt, ValueType::kPtr}, ValueType::kPtr); + FunctionSignature lookup_sign(lookup_name, {list_vt, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List); + + llvm::Type *ptr_ty = llvm::PointerType::getUnqual(ctx.context); + llvm::Type *list_ty = arg_types[0]; // matches args[0] / args[1] (KList struct value) + llvm::Type *u32list_ty = ctx.complex_type.u32list_type; + + // Build call: ptr (KList, ptr) + auto *build_fty = llvm::FunctionType::get(ptr_ty, {list_ty, ptr_ty}, false); + llvm::FunctionCallee build_callee = ctx.module.getOrInsertFunction(build_sign.ToString(), build_fty); + llvm::Value *table_ptr = ctx.builder.CreateCall(build_callee, {args[1], args[2]}, "call_BuildLookupTable"); + + // Lookup call: U32List (KList, ptr, ptr) + auto *lookup_fty = llvm::FunctionType::get(u32list_ty, {list_ty, ptr_ty, ptr_ty}, false); + llvm::FunctionCallee lookup_callee = ctx.module.getOrInsertFunction(lookup_sign.ToString(), lookup_fty); + llvm::Value *result = ctx.builder.CreateCall(lookup_callee, {args[0], table_ptr, args[2]}, "call_LookupTable"); + return result; +} + template uint32_t Find(KList a, typename KList::CElementType value) { for (uint32_t i = 0; i < a.len; ++i) { @@ -93,27 +176,6 @@ llvm::Value *CodegenFindMiss(const FunctionSignature & /*sign*/, const std::vect return ctx.builder.getInt32(kLookupMiss); } -U32ListStruct ListLookupIndexString(StringListStruct a, StringListStruct b, void *exec_context) { - auto *exec_ctx = reinterpret_cast(exec_context); - U32ListStruct result; - result.len = a.len; - result.data = reinterpret_cast(exec_ctx->arena.Allocate(sizeof(uint32_t) * a.len)); - - std::unordered_map table; - table.reserve(static_cast(b.len) * 2); - for (uint32_t j = 0; j < b.len; ++j) { - std::string_view sv(b.data[j].data, b.data[j].len); - table.try_emplace(sv, j); - } - - for (uint32_t i = 0; i < a.len; ++i) { - std::string_view sv(a.data[i].data, a.data[i].len); - auto it = table.find(sv); - result.data[i] = (it == table.end()) ? kLookupMiss : it->second; - } - return result; -} - U32ListStruct ListCompactPositions(U32ListStruct raw, void *exec_context) { auto *exec_ctx = reinterpret_cast(exec_context); uint32_t hits = 0; @@ -208,49 +270,89 @@ U32ListStruct Bucketize(ListType values, ListType boundaries, void *exec_context Status InitListLookupIndexFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kBuildIntName, {ValueType::kU8List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kLookupIntName, {ValueType::kU8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kBuildIntName, {ValueType::kI8List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kLookupIntName, {ValueType::kI8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kBuildIntName, {ValueType::kU16List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kLookupIntName, {ValueType::kU16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kBuildIntName, {ValueType::kI16List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kLookupIntName, {ValueType::kI16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kBuildIntName, {ValueType::kU32List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU32List), - reinterpret_cast(ListLookupIndex))); + FunctionSignature(kLookupIntName, {ValueType::kU32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kBuildIntName, {ValueType::kI32List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupIntName, {ValueType::kI32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kBuildIntName, {ValueType::kU64List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupIntName, {ValueType::kU64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kBuildIntName, {ValueType::kI64List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupIntName, {ValueType::kI64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLookupIndex", {ValueType::kStringList, ValueType::kStringList, ValueType::kPtr}, + FunctionSignature(kBuildIntName, {ValueType::kF32List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupIntName, {ValueType::kF32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kBuildIntName, {ValueType::kF64List, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupIntName, {ValueType::kF64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + reinterpret_cast(LookupTableInt))); + + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kBuildStringName, {ValueType::kStringList, ValueType::kPtr}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableString))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( + FunctionSignature(kLookupStringName, {ValueType::kStringList, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(ListLookupIndexString))); + reinterpret_cast(LookupTableString))); + + for (ValueType vt : {ValueType::kU8List, ValueType::kI8List, ValueType::kU16List, ValueType::kI16List, + ValueType::kU32List, ValueType::kI32List, ValueType::kU64List, ValueType::kI64List, + ValueType::kF32List, ValueType::kF64List, ValueType::kStringList}) { + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( + FunctionSignature("ListLookupIndex", {vt, vt, ValueType::kPtr}, ValueType::kU32List), CodegenListLookupIndex)); + } return Status::OK(); } diff --git a/test/arena_test.cc b/test/arena_test.cc index af11073..825eb00 100644 --- a/test/arena_test.cc +++ b/test/arena_test.cc @@ -309,4 +309,132 @@ TEST(ArenaTest, AllocateZeroAfterReset) { ASSERT_NE(p, nullptr); } +// ============================================================================ +// Create() / finalizer tests +// ============================================================================ + +TEST(ArenaTest, CreateTrivialType) { + Arena arena; + int* p = arena.Create(42); + ASSERT_NE(p, nullptr); + EXPECT_EQ(*p, 42); + EXPECT_TRUE(IsAligned(p, alignof(int))); + + // Trivially destructible types must not register a finalizer; we cannot + // observe the list directly, but we can at least exercise Reset on an + // arena that holds many trivial Create() objects. + for (int i = 0; i < 1000; ++i) { + (void)arena.Create(i); + } + arena.Reset(); + SUCCEED(); +} + +namespace { +struct DtorCounter { + int* counter; + explicit DtorCounter(int* c) : counter(c) {} + ~DtorCounter() { ++*counter; } +}; +} // namespace + +TEST(ArenaTest, CreateRunsDestructorOnReset) { + int counter = 0; + Arena arena; + for (int i = 0; i < 7; ++i) { + (void)arena.Create(&counter); + } + EXPECT_EQ(counter, 0); + arena.Reset(); + EXPECT_EQ(counter, 7); + // Reset must clear the finalizer list, so a second Reset must NOT run + // them again (would otherwise be use-after-free on the bytes the + // dtor just touched). + arena.Reset(); + EXPECT_EQ(counter, 7); +} + +TEST(ArenaTest, CreateRunsDestructorOnDestruction) { + int counter = 0; + { + Arena arena; + for (int i = 0; i < 5; ++i) { + (void)arena.Create(&counter); + } + EXPECT_EQ(counter, 0); + } // ~Arena() + EXPECT_EQ(counter, 5); +} + +namespace { +struct OrderRecorder { + std::vector* order; + int id; + OrderRecorder(std::vector* o, int i) : order(o), id(i) {} + ~OrderRecorder() { order->push_back(id); } +}; +} // namespace + +TEST(ArenaTest, CreateDestructionOrderIsLIFO) { + std::vector destruction_order; + Arena arena; + for (int i = 0; i < 5; ++i) { + (void)arena.Create(&destruction_order, i); + } + arena.Reset(); + ASSERT_EQ(destruction_order.size(), 5U); + EXPECT_EQ(destruction_order, (std::vector{4, 3, 2, 1, 0})); +} + +TEST(ArenaTest, CreateNonTrivialWithHeapState) { + // The whole point: an arena-resident object that itself holds heap + // memory (here, std::vector's element buffer) must have its + // destructor run so the heap memory is freed. Run it under a leak + // sanitizer to actually catch a regression. + Arena arena; + auto* v = arena.Create>(); + ASSERT_NE(v, nullptr); + for (int i = 0; i < 1024; ++i) { + v->push_back(i); + } + EXPECT_EQ(v->size(), 1024U); + // ~Arena() must run ~vector(), which frees the heap-allocated buffer. +} + +TEST(ArenaTest, CreateAlignmentRespected) { + struct alignas(64) Wide { + int x; + }; + Arena arena(/*min_chunk_size=*/16); + Wide* w = arena.Create(); + ASSERT_NE(w, nullptr); + EXPECT_TRUE(IsAligned(w, 64)); +} + +TEST(ArenaTest, CreateAfterResetReusesFirstChunkAndStillFinalizes) { + int counter = 0; + Arena arena(/*min_chunk_size=*/256); + (void)arena.Create(&counter); + arena.Reset(); + EXPECT_EQ(counter, 1); + + // Second round on the recycled first chunk: finalizer list must have + // been cleared so this is a fresh registration, not a stale one. + (void)arena.Create(&counter); + arena.Reset(); + EXPECT_EQ(counter, 2); +} + +TEST(ArenaTest, CreateMixedTrivialAndNonTrivial) { + int counter = 0; + Arena arena; + for (int i = 0; i < 16; ++i) { + (void)arena.Create(i); + (void)arena.Create(&counter); + (void)arena.Allocate(13); // raw bytes interleaved + } + arena.Reset(); + EXPECT_EQ(counter, 16); +} + } // namespace jitfusion From 35c752ffaa3f82d2abb5d9dfc34431048d9c7584 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Mon, 11 May 2026 16:43:03 +0800 Subject: [PATCH 38/41] remove transfer exec_ctx args --- athena/test/pipeline_test.cc | 4 +- include/function_registry.h | 24 + src/codegen/function_codegen.cc | 18 +- src/function/list_arithmetic.cc | 954 +++++++++++----------- src/function/list_basic.cc | 292 ++++--- src/function/list_comparison.cc | 1090 +++++++++++--------------- src/function/list_group.cc | 450 +++++------ src/function/list_indexing.cc | 257 +++--- src/function/string_function_init.cc | 106 ++- src/function_registry.cc | 66 +- test/list_group_test.cc | 129 ++- test/list_indexing_test.cc | 9 +- test/list_misc_test.cc | 7 +- 13 files changed, 1623 insertions(+), 1783 deletions(-) diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index 2ae1614..d7bc2bf 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -82,7 +82,7 @@ TEST(FilterTest, Test1) { std::string code = R"( a = load(entry_arg, 0); b = GenLargeBitmap(a, 3, exec_ctx); - FilterByBitmap(a, b, exec_ctx); + FilterByBitmap(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -102,7 +102,7 @@ TEST(FilterTest, Test2) { a = load(entry_arg, 0); b = load(entry_arg, 1); c = GenLargeBitmap(a, b, exec_ctx); - FilterByBitmap(a, c, exec_ctx); + FilterByBitmap(a, c); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/include/function_registry.h b/include/function_registry.h index 2ba36d4..d6b8b4c 100644 --- a/include/function_registry.h +++ b/include/function_registry.h @@ -81,6 +81,13 @@ struct FunctionStructure { void *c_func_ptr; CodeGenFunc codegen_func; std::function func_attr_setter{nullptr}; + // True for kCFunc registrations whose user-visible signature does NOT + // include the trailing `void* exec_ctx` argument: the C implementation + // still expects exec_ctx as its last parameter, but FunctionNode codegen + // injects it automatically (pulled from the entry function's arg(1)). + // Lets callers and AST authors write the natural N-arg signature while + // keeping the C side ABI (N+1 args, last one is the context) unchanged. + bool needs_exec_ctx{false}; }; class FunctionSignature { @@ -123,6 +130,16 @@ class FunctionRegistry { // Register ReadOnlyCFunc Status RegisterReadOnlyCFunc(const FunctionSignature &func_sign, void *c_func_ptr, bool allow_override = false); + // Register a ReadOnlyCFunc whose C implementation takes a trailing + // `void* exec_ctx` argument that the user-visible signature should NOT + // expose. The user-supplied `func_sign` describes the natural N-arg + // shape (no trailing kPtr); FunctionNode codegen automatically appends + // the entry function's exec_ctx as the final actual argument when + // emitting the call site. The C function itself must still accept the + // trailing void* in its physical signature. + Status RegisterReadOnlyCFuncWithExecCtx(const FunctionSignature &func_sign, void *c_func_ptr, + bool allow_override = false); + // Register StoreCFunc // store_args_index is the index of the args in the function signature that is OuputNode Status RegisterStoreCFunc(const FunctionSignature &func_sign, void *c_func_ptr, uint32_t store_args_index, @@ -131,6 +148,13 @@ class FunctionRegistry { // Register a function that satisfies the commutative property. Status RegisterCommutativeCFunc(const FunctionSignature &func_sign, void *c_func_ptr, bool allow_override = false); + // Register a commutative C function whose user-visible signature does + // NOT include the trailing exec_ctx; mirror semantics of + // RegisterReadOnlyCFuncWithExecCtx (FunctionNode codegen will inject + // the exec_ctx automatically at call sites). + Status RegisterCommutativeCFuncWithExecCtx(const FunctionSignature &func_sign, void *c_func_ptr, + bool allow_override = false); + Status GetFuncBySign(FunctionSignature &func_sign, FunctionStructure *func_struct) const; Status SetCFuncAttr(llvm::Module *m); diff --git a/src/codegen/function_codegen.cc b/src/codegen/function_codegen.cc index b43a7f5..42d39a0 100644 --- a/src/codegen/function_codegen.cc +++ b/src/codegen/function_codegen.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-22 14:25:33 * @Last Modified by: victorika - * @Last Modified time: 2025-01-22 16:50:36 + * @Last Modified time: 2026-05-11 16:17:09 */ #include #include "codegen.h" @@ -32,17 +32,31 @@ Status CodeGen::Visit(FunctionNode& function_node) { FunctionSignature sign(function_node.GetFuncName(), args_type_list, ValueType::kUnknown); FunctionStructure func_struct; JF_RETURN_NOT_OK(ctx_.function_registry->GetFuncBySign(sign, &func_struct)); + switch (func_struct.func_type) { case FunctionType::kLLVMIntrinicFunc: { value_ = func_struct.codegen_func(sign, args_llvm_type_list, args_llvm_value_list, ctx_); } break; case FunctionType::kCFunc: { + std::string call_symbol_name; + if (func_struct.needs_exec_ctx) { + llvm::Type* ptr_ty = llvm::PointerType::getUnqual(ctx_.context); + args_llvm_type_list.emplace_back(ptr_ty); + args_llvm_value_list.emplace_back(ctx_.entry_function->getArg(1)); + std::vector ctx_param_types = sign.GetParamTypes(); + ctx_param_types.emplace_back(ValueType::kPtr); + FunctionSignature ctx_sign(sign.GetName(), std::move(ctx_param_types), sign.GetRetType()); + call_symbol_name = ctx_sign.ToString(); + } else { + call_symbol_name = sign.ToString(); + } + llvm::Type* llvm_ret_type; JF_RETURN_NOT_OK(ValueTypeToLLVMType(ctx_, function_node.GetReturnType(), &llvm_ret_type)); llvm::FunctionType* func_type = llvm::FunctionType::get(llvm_ret_type, llvm::ArrayRef(args_llvm_type_list), false); - llvm::FunctionCallee call_func_callee = ctx_.module.getOrInsertFunction(sign.ToString(), func_type); + llvm::FunctionCallee call_func_callee = ctx_.module.getOrInsertFunction(call_symbol_name, func_type); if (function_node.GetReturnType() == ValueType::kVoid) { ctx_.builder.CreateCall(call_func_callee, args_llvm_value_list); diff --git a/src/function/list_arithmetic.cc b/src/function/list_arithmetic.cc index bedecb6..33a5df9 100644 --- a/src/function/list_arithmetic.cc +++ b/src/function/list_arithmetic.cc @@ -635,729 +635,707 @@ ListType ListMax(ListType a, typename ListType::CElementType b, void *exec_conte } Status InitListAddFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListAdd))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListAddList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListAdd", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListAddList))); return Status::OK(); } Status InitListSubFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListSub))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListSubList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListSub", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListSubList))); return Status::OK(); } Status InitListMulFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMul))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListMulList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListMul", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListMulList))); return Status::OK(); } Status InitListDivFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListDiv))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListDivList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListDiv", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListDivList))); return Status::OK(); } Status InitListModFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMod))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListModList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMod", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListModList))); return Status::OK(); } Status InitListBitwiseAndFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseAnd))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseAndList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseAnd", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseAndList))); return Status::OK(); } Status InitListBitwiseOrFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseOr))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseOrList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseOr", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseOrList))); return Status::OK(); } Status InitListBitwiseXorFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListBitwiseXor))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListBitwiseXorList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("ListBitwiseXor", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListBitwiseXorList))); return Status::OK(); } Status InitListExpFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListExp))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListExp", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListExp))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListExp", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListExp))); return Status::OK(); } Status InitListLogFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog))); return Status::OK(); } Status InitListLog2Func(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog2))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog2", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog2))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog2", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog2))); return Status::OK(); } Status InitListLog10Func(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kU64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI8List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI16List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI32List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kI64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListLog10))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListLog10", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU8List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU16List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU32List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kU64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI8List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI16List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI32List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kI64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListLog10))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListLog10", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListLog10))); return Status::OK(); } Status InitListCeilFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCeil", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListCeil))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCeil", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListCeil))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListCeil", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListCeil))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListCeil", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListCeil))); return Status::OK(); } Status InitListFloorFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListFloor", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListFloor))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListFloor", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListFloor))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListFloor", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListFloor))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListFloor", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListFloor))); return Status::OK(); } Status InitListRoundFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListRound", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(ListRound))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListRound", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(ListRound))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListRound", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(ListRound))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("ListRound", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(ListRound))); return Status::OK(); } Status InitListMinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMin", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMin", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMin))); return Status::OK(); } Status InitListMaxFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListMax", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListMax", {ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListMax))); return Status::OK(); } diff --git a/src/function/list_basic.cc b/src/function/list_basic.cc index 6560267..3f67f49 100644 --- a/src/function/list_basic.cc +++ b/src/function/list_basic.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-02-09 15:09:08 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 15:37:01 + * @Last Modified time: 2026-05-11 16:38:55 */ #include #include @@ -251,9 +251,8 @@ inline StringListStruct UniqueString(StringListStruct a, void *exec_context) { } Status InitCrossJoinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CrossJoin", - {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CrossJoin", {ValueType::kStringList, ValueType::kStringList, ValueType::kString}, ValueType::kStringList), reinterpret_cast(CrossJoinString))); return Status::OK(); @@ -310,9 +309,8 @@ inline StringListStruct ZipConcatString(StringListStruct a, StringListStruct b, } Status InitZipConcatFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ZipConcat", - {ValueType::kStringList, ValueType::kStringList, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ZipConcat", {ValueType::kStringList, ValueType::kStringList, ValueType::kString}, ValueType::kStringList), reinterpret_cast(ZipConcatString))); return Status::OK(); @@ -320,75 +318,74 @@ Status InitZipConcatFunc(FunctionRegistry *reg) { Status InitUniqueFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK( - reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK( - reg->RegisterReadOnlyCFunc(FunctionSignature("Unique", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(Unique))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Unique", {ValueType::kStringList, ValueType::kPtr}, ValueType::kStringList), + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("Unique", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(Unique))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Unique", {ValueType::kStringList}, ValueType::kStringList), reinterpret_cast(UniqueString))); return Status::OK(); } Status InitListConcatFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(ListConcat))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListConcat", {ValueType::kStringList, ValueType::kStringList, ValueType::kPtr}, - ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListConcat", {ValueType::kStringList, ValueType::kStringList}, ValueType::kStringList), reinterpret_cast(ListConcat))); return Status::OK(); } @@ -457,67 +454,67 @@ Status InitLenFunc(FunctionRegistry *reg) { } Status InitSortFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(SortAsc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortAsc", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(SortAsc))); - - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU16List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU64List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI8List, ValueType::kPtr}, ValueType::kI8List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI16List, ValueType::kPtr}, ValueType::kI16List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI32List, ValueType::kPtr}, ValueType::kI32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kI64List, ValueType::kPtr}, ValueType::kI64List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kF32List, ValueType::kPtr}, ValueType::kF32List), - reinterpret_cast(SortDesc))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("SortDesc", {ValueType::kF64List, ValueType::kPtr}, ValueType::kF64List), - reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(SortAsc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortAsc", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(SortAsc))); + + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU8List}, ValueType::kU8List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU16List}, ValueType::kU16List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kU64List}, ValueType::kU64List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI8List}, ValueType::kI8List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI16List}, ValueType::kI16List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI32List}, ValueType::kI32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kI64List}, ValueType::kI64List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kF32List}, ValueType::kF32List), + reinterpret_cast(SortDesc))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("SortDesc", {ValueType::kF64List}, ValueType::kF64List), + reinterpret_cast(SortDesc))); return Status::OK(); } @@ -598,8 +595,9 @@ Status RegisterNumericListCast(FunctionRegistry *reg, const std::string &func_na if (input_list_vt == output_list_vt) { return Status::OK(); } - return reg->RegisterReadOnlyCFunc(FunctionSignature(func_name, {input_list_vt, ValueType::kPtr}, output_list_vt), - reinterpret_cast(ListCastNumericToNumeric)); + return reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(func_name, {input_list_vt}, output_list_vt), + reinterpret_cast(ListCastNumericToNumeric)); } template @@ -626,9 +624,9 @@ Status RegisterAllInputsForNumericListCast(FunctionRegistry *reg, const std::str JF_RETURN_NOT_OK( (RegisterNumericListCast(reg, func_name, ValueType::kF64List, output_list_vt))); if constexpr (!std::is_floating_point_v) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(func_name, {ValueType::kStringList, ValueType::kPtr}, output_list_vt), - reinterpret_cast(ListCastStringToNumeric))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(func_name, {ValueType::kStringList}, output_list_vt), + reinterpret_cast(ListCastStringToNumeric))); } return Status::OK(); } @@ -645,35 +643,35 @@ Status InitListCastFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(RegisterAllInputsForNumericListCast(reg, "CastF32List", ValueType::kF32List)); JF_RETURN_NOT_OK(RegisterAllInputsForNumericListCast(reg, "CastF64List", ValueType::kF64List)); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU8List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU8List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI8List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI8List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU16List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU16List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI16List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI16List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kU64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kU64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kI64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kI64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kF32List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kF32List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastStringList", {ValueType::kF64List, ValueType::kPtr}, ValueType::kStringList), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("CastStringList", {ValueType::kF64List}, ValueType::kStringList), reinterpret_cast(ListCastNumericToString))); return Status::OK(); diff --git a/src/function/list_comparison.cc b/src/function/list_comparison.cc index 4fc9d28..e7b2912 100644 --- a/src/function/list_comparison.cc +++ b/src/function/list_comparison.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-02-09 14:48:23 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 14:31:05 + * @Last Modified time: 2026-05-11 16:35:09 */ #include #include "codegen/codegen.h" @@ -426,934 +426,766 @@ ListType FilterByBitmap(ListType a, U8ListStruct bitmap, uint32_t bits_cnt, void } Status InitIfLargeFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLarge))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLarge", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLarge", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLarge))); return Status::OK(); } Status InitIfLargeEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLargeEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLargeEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLargeEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLargeEqual))); return Status::OK(); } Status InitIfEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfEqual))); return Status::OK(); } Status InitIfLessFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLess))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLess", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLess", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLess))); return Status::OK(); } Status InitIfLessEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfLessEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfLessEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfLessEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfLessEqual))); return Status::OK(); } Status InitIfNotEqualFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU8List, ValueType::kU8, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU16List, ValueType::kU16, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU32List, ValueType::kU32, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kU64List, ValueType::kU64, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI8List, ValueType::kI8, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI16List, ValueType::kI16, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI32List, ValueType::kI32, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kI64List, ValueType::kI64, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kF32List, ValueType::kF32, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfNotEqual))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfNotEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfNotEqual", {ValueType::kF64List, ValueType::kF64, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfNotEqual))); return Status::OK(); } Status InitIfByBitmapLLRB(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(IfByBitmapLLRB))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(IfByBitmapLLRB))); return Status::OK(); } Status InitIfByBitmapLBRL(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16, ValueType::kI16List, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32, ValueType::kI32List, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64, ValueType::kI64List, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32, ValueType::kF32List, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(IfByBitmapLBRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64, ValueType::kF64List, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(IfByBitmapLBRL))); return Status::OK(); } Status InitIfByBitmapLLRL(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU16List, ValueType::kU16List}, ValueType::kU16List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kU64List, ValueType::kU64List}, ValueType::kU64List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI8List, ValueType::kI8List}, ValueType::kI8List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI16List, ValueType::kI16List}, ValueType::kI16List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI32List, ValueType::kI32List}, ValueType::kI32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kI64List, ValueType::kI64List}, ValueType::kI64List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF32List, ValueType::kF32List}, ValueType::kF32List), reinterpret_cast(IfByBitmapLLRL))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("IfByBitmap", {ValueType::kU8List, ValueType::kF64List, ValueType::kF64List}, ValueType::kF64List), reinterpret_cast(IfByBitmapLLRL))); return Status::OK(); } Status InitGenLargeBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLargeBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLargeEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLargeEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLargeEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLessBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLessBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenLessEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenLessEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenLessEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitGenNotEqualBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8, ValueType::kPtr}, ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32}, ValueType::kU8List), reinterpret_cast(GenBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64}, ValueType::kU8List), reinterpret_cast(GenBitmap))); return Status::OK(); } Status InitGenNotEqualBitmapListFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); - JF_RETURN_NOT_OK(reg->RegisterCommutativeCFunc( - FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterCommutativeCFuncWithExecCtx( + FunctionSignature("GenNotEqualBitmap", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU8List), reinterpret_cast(GenBitmapList))); return Status::OK(); } Status InitFilterByBitmapFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(FilterByBitmap))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(FilterByBitmap))); return Status::OK(); @@ -1363,7 +1195,7 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *list_value = arg_llvm_value_list.at(0); auto *bitmap_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *list_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -1377,7 +1209,13 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v ctx.module.getOrInsertFunction(count_bits_sign.ToString(), count_bits_func_type); llvm::Value *bits_cnt_value = ctx.builder.CreateCall(count_bits_callee, {bitmap_value}, "bits_cnt"); - // FilterByBitmap(list, bitmap, bits_cnt, ctx) -> + // FilterByBitmap is registered via RegisterReadOnlyCFuncWithExecCtx, which + // exposes two signatures: the modern (no-ctx) one for resolution and a + // legacy ctx-bearing one whose ToString() is what MappingToJIT actually + // publishes as a JIT symbol. Use the *legacy* name here so the IR-level + // declaration we emit matches MappingToJIT's symbol exactly, mirroring + // the FunctionNode codegen path that auto-injects exec_ctx and emits + // calls under the ctx-bearing name. FunctionSignature filter_sign("FilterByBitmap", {sign.GetParamTypes().at(0), ValueType::kU8List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -1390,44 +1228,34 @@ llvm::Value *EmitFilterByBitmapSugar(const FunctionSignature &sign, const std::v Status InitFilterByBitmapSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU8List), + FunctionSignature("FilterByBitmap", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU8List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU16List), + FunctionSignature("FilterByBitmap", {ValueType::kU16List, ValueType::kU8List}, ValueType::kU16List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU32List), + FunctionSignature("FilterByBitmap", {ValueType::kU32List, ValueType::kU8List}, ValueType::kU32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kU64List), + FunctionSignature("FilterByBitmap", {ValueType::kU64List, ValueType::kU8List}, ValueType::kU64List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI8List), + FunctionSignature("FilterByBitmap", {ValueType::kI8List, ValueType::kU8List}, ValueType::kI8List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI16List), + FunctionSignature("FilterByBitmap", {ValueType::kI16List, ValueType::kU8List}, ValueType::kI16List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI32List), + FunctionSignature("FilterByBitmap", {ValueType::kI32List, ValueType::kU8List}, ValueType::kI32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kI64List), + FunctionSignature("FilterByBitmap", {ValueType::kI64List, ValueType::kU8List}, ValueType::kI64List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kF32List), + FunctionSignature("FilterByBitmap", {ValueType::kF32List, ValueType::kU8List}, ValueType::kF32List), EmitFilterByBitmapSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List, ValueType::kPtr}, - ValueType::kF64List), + FunctionSignature("FilterByBitmap", {ValueType::kF64List, ValueType::kU8List}, ValueType::kF64List), EmitFilterByBitmapSugar)); return Status::OK(); } diff --git a/src/function/list_group.cc b/src/function/list_group.cc index 9294137..70f9460 100644 --- a/src/function/list_group.cc +++ b/src/function/list_group.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 11:35:00 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 11:35:00 + * @Last Modified time: 2026-05-11 16:32:30 */ #include #include @@ -182,38 +182,38 @@ F64ListStruct GroupAvg(VList values, U32ListStruct group_index, uint32_t distinc } Status InitGroupIndexFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), - reinterpret_cast(GroupIndex))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupIndex", {ValueType::kStringList, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU8List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI8List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU16List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI16List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kU64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kI64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kF32List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("GroupIndex", {ValueType::kF64List}, ValueType::kU32List), + reinterpret_cast(GroupIndex))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupIndex", {ValueType::kStringList}, ValueType::kU32List), reinterpret_cast(GroupIndexString))); return Status::OK(); } @@ -225,48 +225,38 @@ Status InitGroupCountFunc(FunctionRegistry *reg) { } Status InitGroupKeysFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupKeys))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kU32}, ValueType::kStringList), reinterpret_cast(GroupKeys))); return Status::OK(); @@ -276,7 +266,7 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *keys_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *keys_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -289,6 +279,10 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of GroupKeys so the IR-level + // symbol we emit matches what MappingToJIT publishes (and what FunctionNode + // codegen would emit for a direct call): the ctx-bearing name lets GVN/CSE + // share a single declaration with all other GroupKeys call sites. FunctionSignature group_keys_sign("GroupKeys", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -302,84 +296,73 @@ llvm::Value *EmitGroupKeysSugar(const FunctionSignature &sign, const std::vector Status InitGroupKeysSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), + FunctionSignature("GroupKeys", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), + FunctionSignature("GroupKeys", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupKeys", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupKeys", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupKeys", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupKeys", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupKeys", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupKeys", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupKeys", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupKeys", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupKeysSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List, ValueType::kPtr}, - ValueType::kStringList), + FunctionSignature("GroupKeys", {ValueType::kStringList, ValueType::kU32List}, ValueType::kStringList), EmitGroupKeysSugar)); return Status::OK(); } Status InitGroupSumFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupSum))); // Unsigned integers promote to u64. - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupSum))); // Floating-point promotes to f64. - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupSum))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupSum))); return Status::OK(); } @@ -388,7 +371,7 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -404,6 +387,10 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of GroupSum so getOrInsertFunction + // lands on the same declaration that MappingToJIT publishes (and the same + // one FunctionNode codegen emits for direct user calls). That keeps GVN/CSE + // happy across sugar / direct call shapes. FunctionSignature group_sum_sign("GroupSum", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -417,122 +404,102 @@ llvm::Value *EmitGroupSumSugar(const FunctionSignature &sign, const std::vector< Status InitGroupSumSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupSum", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupSum", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupSum", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupSumSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupSum", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupSumSugar)); return Status::OK(); } Status InitGroupMaxFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupMax))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupMax))); return Status::OK(); } Status InitGroupMinFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kU8List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kI8List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kU16List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kI16List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kI32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kU64List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kI64List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF32List), reinterpret_cast(GroupMin))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupMin))); return Status::OK(); } @@ -543,7 +510,7 @@ llvm::Value *EmitGroupExtremaSugar(const std::string &kernel_name, const Functio const char *call_name) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -556,6 +523,9 @@ llvm::Value *EmitGroupExtremaSugar(const std::string &kernel_name, const Functio ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the *legacy* ctx-bearing signature of the GroupMin/GroupMax kernel + // so the IR-level declaration matches MappingToJIT's published symbol and + // FunctionNode codegen's direct-call name. FunctionSignature kernel_sign(kernel_name, {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -578,112 +548,98 @@ llvm::Value *EmitGroupMinSugar(const FunctionSignature &sign, const std::vector< Status InitGroupMaxSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), - EmitGroupMaxSugar)); + FunctionSignature("GroupMax", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), - EmitGroupMaxSugar)); + FunctionSignature("GroupMax", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupMax", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupMax", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupMax", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupMax", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupMax", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupMax", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupMax", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupMaxSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupMax", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupMaxSugar)); return Status::OK(); } Status InitGroupMinSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU8List), - EmitGroupMinSugar)); + FunctionSignature("GroupMin", {ValueType::kU8List, ValueType::kU32List}, ValueType::kU8List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI8List), - EmitGroupMinSugar)); + FunctionSignature("GroupMin", {ValueType::kI8List, ValueType::kU32List}, ValueType::kI8List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU16List), + FunctionSignature("GroupMin", {ValueType::kU16List, ValueType::kU32List}, ValueType::kU16List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI16List), + FunctionSignature("GroupMin", {ValueType::kI16List, ValueType::kU32List}, ValueType::kI16List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + FunctionSignature("GroupMin", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI32List), + FunctionSignature("GroupMin", {ValueType::kI32List, ValueType::kU32List}, ValueType::kI32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU64List), + FunctionSignature("GroupMin", {ValueType::kU64List, ValueType::kU32List}, ValueType::kU64List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kI64List), + FunctionSignature("GroupMin", {ValueType::kI64List, ValueType::kU32List}, ValueType::kI64List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF32List), + FunctionSignature("GroupMin", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF32List), EmitGroupMinSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupMin", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupMinSugar)); return Status::OK(); } Status InitGroupAvgFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kU32}, ValueType::kF64List), reinterpret_cast(GroupAvg))); return Status::OK(); } @@ -692,7 +648,7 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< const std::vector &arg_llvm_value_list, IRCodeGenContext &ctx) { auto *values_value = arg_llvm_value_list.at(0); auto *group_index_value = arg_llvm_value_list.at(1); - auto *exec_context_value = arg_llvm_value_list.at(2); + auto *exec_context_value = ctx.entry_function->getArg(1); auto *values_llvm_type = arg_llvm_type_list.at(0); auto *i32_ty = llvm::Type::getInt32Ty(ctx.context); @@ -708,6 +664,10 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< ctx.module.getOrInsertFunction(group_count_sign.ToString(), group_count_func_type); llvm::Value *distinct_value = ctx.builder.CreateCall(group_count_callee, {group_index_value}, "group_count"); + // Mirror the registry view of GroupAvg (no trailing exec_ctx in its + // Mirror the *legacy* ctx-bearing signature of GroupAvg so getOrInsertFunction + // lands on the same Function* MappingToJIT publishes and FunctionNode codegen + // emits for direct user calls. FunctionSignature group_avg_sign("GroupAvg", {sign.GetParamTypes().at(0), ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, sign.GetRetType()); @@ -721,34 +681,34 @@ llvm::Value *EmitGroupAvgSugar(const FunctionSignature &sign, const std::vector< Status InitGroupAvgSugarFunc(FunctionRegistry *reg) { JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU8List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI8List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU16List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI16List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kU64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kI64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kF32List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List, ValueType::kPtr}, ValueType::kF64List), + FunctionSignature("GroupAvg", {ValueType::kF64List, ValueType::kU32List}, ValueType::kF64List), EmitGroupAvgSugar)); return Status::OK(); } diff --git a/src/function/list_indexing.cc b/src/function/list_indexing.cc index 8c7fbd5..39318a6 100644 --- a/src/function/list_indexing.cc +++ b/src/function/list_indexing.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:15:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-11 14:55:04 + * @Last Modified time: 2026-05-11 16:30:32 */ #include #include @@ -91,22 +91,32 @@ constexpr const char *kLookupStringName = "__LookupTableString"; bool IsStringListType(ValueType v) { return v == ValueType::kStringList; } -// Lowering for the user-facing ListLookupIndex(a, b, ctx). Emits two -// readonly C calls - one to build the hash table over `b`, one to probe -// the table with `a`. LLVM CSE merges the BuildLookupTable_* call across -// multiple ListLookupIndex sites that share the same `b`. +// Lowering for the user-facing ListLookupIndex(a, b). The user-visible +// signature does NOT include exec_ctx — the helper functions it lowers to +// are registered via RegisterReadOnlyCFuncWithExecCtx, meaning their C +// implementations consume a trailing void* ctx but the registry view of +// the signature does not advertise it. We pull ctx from entry_function's +// arg(1) ourselves and append it to each call site, so the emitted LLVM +// `Function` types still match the C ABI (N+1 args, last one ptr). +// +// Two readonly C calls are emitted: one to build the hash table over `b`, +// one to probe the table with `a`. LLVM CSE merges the BuildLookupTable_* +// call across multiple ListLookupIndex sites that share the same `b`. llvm::Value *CodegenListLookupIndex(const FunctionSignature &sign, const std::vector &arg_types, const std::vector &args, IRCodeGenContext &ctx) { - // sign.GetParamTypes() = {KList, KList, kPtr}; args[0]=a, args[1]=b, args[2]=exec_ctx + // sign.GetParamTypes() = {KList, KList}; args[0]=a, args[1]=b. const auto ¶m_types = sign.GetParamTypes(); const ValueType list_vt = param_types[0]; const bool is_string = IsStringListType(list_vt); const char *build_name = is_string ? kBuildStringName : kBuildIntName; const char *lookup_name = is_string ? kLookupStringName : kLookupIntName; - // Each helper has its own *registered* signature (so MappingToJIT and - // SetCFuncAttr can find them). Mirror those signatures here when - // asking the module for the function declaration. + // Mirror the *legacy* ctx-bearing signatures of the helpers (the names + // MappingToJIT actually publishes for the underlying C symbols, and the + // ones FunctionNode codegen would emit for direct user calls). Using the + // ctx-bearing form here means a single LLVM Function declaration is + // shared between this sugar's emit and any future direct calls of + // BuildLookupTable/LookupTable, letting GVN/CSE merge across both. FunctionSignature build_sign(build_name, {list_vt, ValueType::kPtr}, ValueType::kPtr); FunctionSignature lookup_sign(lookup_name, {list_vt, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List); @@ -114,15 +124,20 @@ llvm::Value *CodegenListLookupIndex(const FunctionSignature &sign, const std::ve llvm::Type *list_ty = arg_types[0]; // matches args[0] / args[1] (KList struct value) llvm::Type *u32list_ty = ctx.complex_type.u32list_type; - // Build call: ptr (KList, ptr) + llvm::Value *exec_ctx = ctx.entry_function->getArg(1); + + // Build call: ptr (KList, ptr) — the ptr at the end is the auto-injected + // exec_ctx; the helper's user-visible signature is just (KList). auto *build_fty = llvm::FunctionType::get(ptr_ty, {list_ty, ptr_ty}, false); llvm::FunctionCallee build_callee = ctx.module.getOrInsertFunction(build_sign.ToString(), build_fty); - llvm::Value *table_ptr = ctx.builder.CreateCall(build_callee, {args[1], args[2]}, "call_BuildLookupTable"); + llvm::Value *table_ptr = ctx.builder.CreateCall(build_callee, {args[1], exec_ctx}, "call_BuildLookupTable"); - // Lookup call: U32List (KList, ptr, ptr) + // Lookup call: U32List (KList, ptr, ptr) — same trick: trailing ptr is + // exec_ctx, the user-visible signature is just (KList, ptr) where the + // first ptr is the table handle returned above. auto *lookup_fty = llvm::FunctionType::get(u32list_ty, {list_ty, ptr_ty, ptr_ty}, false); llvm::FunctionCallee lookup_callee = ctx.module.getOrInsertFunction(lookup_sign.ToString(), lookup_fty); - llvm::Value *result = ctx.builder.CreateCall(lookup_callee, {args[0], table_ptr, args[2]}, "call_LookupTable"); + llvm::Value *result = ctx.builder.CreateCall(lookup_callee, {args[0], table_ptr, exec_ctx}, "call_LookupTable"); return result; } @@ -269,89 +284,88 @@ U32ListStruct Bucketize(ListType values, ListType boundaries, void *exec_context } Status InitListLookupIndexFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU8List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU8List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI8List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI8List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI8List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU16List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU16List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI16List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI16List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI16List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kU64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kU64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kU64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kI64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kI64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kI64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kF32List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kF32List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kF32List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildIntName, {ValueType::kF64List, ValueType::kPtr}, ValueType::kPtr), - reinterpret_cast(BuildLookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupIntName, {ValueType::kF64List, ValueType::kPtr, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature(kBuildIntName, {ValueType::kF64List}, ValueType::kPtr), + reinterpret_cast(BuildLookupTableInt))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupIntName, {ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableInt))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kBuildStringName, {ValueType::kStringList, ValueType::kPtr}, ValueType::kPtr), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kBuildStringName, {ValueType::kStringList}, ValueType::kPtr), reinterpret_cast(BuildLookupTableString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature(kLookupStringName, {ValueType::kStringList, ValueType::kPtr, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature(kLookupStringName, {ValueType::kStringList, ValueType::kPtr}, ValueType::kU32List), reinterpret_cast(LookupTableString))); for (ValueType vt : {ValueType::kU8List, ValueType::kI8List, ValueType::kU16List, ValueType::kI16List, ValueType::kU32List, ValueType::kI32List, ValueType::kU64List, ValueType::kI64List, ValueType::kF32List, ValueType::kF64List, ValueType::kStringList}) { - JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc( - FunctionSignature("ListLookupIndex", {vt, vt, ValueType::kPtr}, ValueType::kU32List), CodegenListLookupIndex)); + JF_RETURN_NOT_OK(reg->RegisterLLVMIntrinicFunc(FunctionSignature("ListLookupIndex", {vt, vt}, ValueType::kU32List), + CodegenListLookupIndex)); } return Status::OK(); } @@ -436,95 +450,84 @@ Status InitFindMissFunc(FunctionRegistry *reg) { } Status InitListCompactFuncs(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCompactPositions", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListCompactPositions", {ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListCompactPositions))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListCompactIndex", {ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListCompactIndex", {ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(ListCompactIndex))); return Status::OK(); } Status InitListGatherFunc(FunctionRegistry *reg) { // Signature: ListGather(values, idx, default, ctx) - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU8List, ValueType::kU32List, ValueType::kU8, ValueType::kPtr}, - ValueType::kU8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU8List, ValueType::kU32List, ValueType::kU8}, ValueType::kU8List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI8List, ValueType::kU32List, ValueType::kI8, ValueType::kPtr}, - ValueType::kI8List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI8List, ValueType::kU32List, ValueType::kI8}, ValueType::kI8List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU16List, ValueType::kU32List, ValueType::kU16, ValueType::kPtr}, - ValueType::kU16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU16List, ValueType::kU32List, ValueType::kU16}, ValueType::kU16List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI16List, ValueType::kU32List, ValueType::kI16, ValueType::kPtr}, - ValueType::kI16List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI16List, ValueType::kU32List, ValueType::kI16}, ValueType::kI16List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32, ValueType::kPtr}, - ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU32List, ValueType::kU32List, ValueType::kU32}, ValueType::kU32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI32List, ValueType::kU32List, ValueType::kI32, ValueType::kPtr}, - ValueType::kI32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI32List, ValueType::kU32List, ValueType::kI32}, ValueType::kI32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kU64List, ValueType::kU32List, ValueType::kU64, ValueType::kPtr}, - ValueType::kU64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kU64List, ValueType::kU32List, ValueType::kU64}, ValueType::kU64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kI64List, ValueType::kU32List, ValueType::kI64, ValueType::kPtr}, - ValueType::kI64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kI64List, ValueType::kU32List, ValueType::kI64}, ValueType::kI64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kF32List, ValueType::kU32List, ValueType::kF32, ValueType::kPtr}, - ValueType::kF32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kF32List, ValueType::kU32List, ValueType::kF32}, ValueType::kF32List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", {ValueType::kF64List, ValueType::kU32List, ValueType::kF64, ValueType::kPtr}, - ValueType::kF64List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kF64List, ValueType::kU32List, ValueType::kF64}, ValueType::kF64List), reinterpret_cast(ListGather))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("ListGather", - {ValueType::kStringList, ValueType::kU32List, ValueType::kString, ValueType::kPtr}, + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("ListGather", {ValueType::kStringList, ValueType::kU32List, ValueType::kString}, ValueType::kStringList), reinterpret_cast(ListGather))); return Status::OK(); } Status InitBucketizeFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU8List, ValueType::kU8List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU8List, ValueType::kU8List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI8List, ValueType::kI8List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI8List, ValueType::kI8List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU16List, ValueType::kU16List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU16List, ValueType::kU16List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI16List, ValueType::kI16List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI16List, ValueType::kI16List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU32List, ValueType::kU32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU32List, ValueType::kU32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI32List, ValueType::kI32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI32List, ValueType::kI32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kU64List, ValueType::kU64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kU64List, ValueType::kU64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kI64List, ValueType::kI64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kI64List, ValueType::kI64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kF32List, ValueType::kF32List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kF32List, ValueType::kF32List}, ValueType::kU32List), reinterpret_cast(Bucketize))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("Bucketize", {ValueType::kF64List, ValueType::kF64List, ValueType::kPtr}, ValueType::kU32List), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("Bucketize", {ValueType::kF64List, ValueType::kF64List}, ValueType::kU32List), reinterpret_cast(Bucketize))); return Status::OK(); } diff --git a/src/function/string_function_init.cc b/src/function/string_function_init.cc index c6a83ad..86b0be7 100644 --- a/src/function/string_function_init.cc +++ b/src/function/string_function_init.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-23 12:36:51 * @Last Modified by: victorika - * @Last Modified time: 2026-04-03 16:36:37 + * @Last Modified time: 2026-05-11 16:38:52 */ #include #include @@ -74,8 +74,8 @@ llvm::Value *CallBuiltinStringLenFunction(const FunctionSignature & /*sign*/, } // namespace Status InitStringInternalFunc(FunctionRegistry *reg) { - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("StringConcat", {ValueType::kString, ValueType::kString, ValueType::kPtr}, ValueType::kString), + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFuncWithExecCtx( + FunctionSignature("StringConcat", {ValueType::kString, ValueType::kString}, ValueType::kString), reinterpret_cast(StringConcat))); JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( FunctionSignature("StringCmp", {ValueType::kString, ValueType::kString}, ValueType::kI32), @@ -86,61 +86,53 @@ Status InitStringInternalFunc(FunctionRegistry *reg) { FunctionSignature("StringContains", {ValueType::kString, ValueType::kString}, ValueType::kU8), reinterpret_cast(StringContains))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU8, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI8, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU16, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI16, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kU64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kI64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kF32, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastString", {ValueType::kF64, ValueType::kPtr}, ValueType::kString), - reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU8}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI8}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU16}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI16}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kU64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kI64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kF32}, ValueType::kString), + reinterpret_cast(CastNumericToString))); + JF_RETURN_NOT_OK( + reg->RegisterReadOnlyCFuncWithExecCtx(FunctionSignature("CastString", {ValueType::kF64}, ValueType::kString), + reinterpret_cast(CastNumericToString))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU8", {ValueType::kString}, ValueType::kU8), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI8", {ValueType::kString}, ValueType::kI8), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU16", {ValueType::kString}, ValueType::kU16), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI16", {ValueType::kString}, ValueType::kI16), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU32", {ValueType::kString}, ValueType::kU32), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI32", {ValueType::kString}, ValueType::kI32), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastU64", {ValueType::kString}, ValueType::kU64), - reinterpret_cast(CastStringToNumeric))); - JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc( - FunctionSignature("CastI64", {ValueType::kString}, ValueType::kI64), - reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU8", {ValueType::kString}, ValueType::kU8), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI8", {ValueType::kString}, ValueType::kI8), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU16", {ValueType::kString}, ValueType::kU16), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI16", {ValueType::kString}, ValueType::kI16), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU32", {ValueType::kString}, ValueType::kU32), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI32", {ValueType::kString}, ValueType::kI32), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastU64", {ValueType::kString}, ValueType::kU64), + reinterpret_cast(CastStringToNumeric))); + JF_RETURN_NOT_OK(reg->RegisterReadOnlyCFunc(FunctionSignature("CastI64", {ValueType::kString}, ValueType::kI64), + reinterpret_cast(CastStringToNumeric))); return Status::OK(); } diff --git a/src/function_registry.cc b/src/function_registry.cc index 2f28f0a..d706377 100644 --- a/src/function_registry.cc +++ b/src/function_registry.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 14:26:36 * @Last Modified by: victorika - * @Last Modified time: 2025-03-04 19:03:28 + * @Last Modified time: 2026-05-11 16:37:39 */ #include "function_registry.h" #include @@ -138,6 +138,36 @@ Status FunctionRegistry::RegisterReadOnlyCFunc(const FunctionSignature& func_sig return RegisterFunc(func_sign, std::move(func_struct), allow_override); } +Status FunctionRegistry::RegisterReadOnlyCFuncWithExecCtx(const FunctionSignature& func_sign, void* c_func_ptr, + bool allow_override) { + if (nullptr == c_func_ptr) { + return Status::InvalidArgument("c_func_ptr is nullptr"); + } + // Modern user-visible signature: no trailing kPtr; codegen auto-injects + // exec_ctx when emitting the call so the C ABI (N+1 args) is preserved. + { + FunctionStructure func_struct; + func_struct.func_type = FunctionType::kCFunc; + func_struct.c_func_ptr = c_func_ptr; + func_struct.func_attr_setter = ReadOnlyFunctionAttributeSetter; + func_struct.needs_exec_ctx = true; + JF_RETURN_NOT_OK(RegisterFunc(func_sign, std::move(func_struct), allow_override)); + } + // Legacy compatibility signature: with trailing kPtr; behaves exactly + // like the old RegisterReadOnlyCFunc registration. Existing callers + // (AST builders that still create an ExecContextNode tail arg, or + // athena DSL code using `EXEC_CTX`) keep working unchanged. + std::vector legacy_params = func_sign.GetParamTypes(); + legacy_params.emplace_back(ValueType::kPtr); + FunctionSignature legacy_sign(func_sign.GetName(), std::move(legacy_params), func_sign.GetRetType()); + FunctionStructure legacy_struct; + legacy_struct.func_type = FunctionType::kCFunc; + legacy_struct.c_func_ptr = c_func_ptr; + legacy_struct.func_attr_setter = ReadOnlyFunctionAttributeSetter; + legacy_struct.needs_exec_ctx = false; + return RegisterFunc(legacy_sign, std::move(legacy_struct), allow_override); +} + Status FunctionRegistry::RegisterStoreCFunc(const FunctionSignature& func_sign, void* c_func_ptr, uint32_t store_args_index, bool allow_override) { if (nullptr == c_func_ptr) { @@ -162,6 +192,34 @@ Status FunctionRegistry::RegisterCommutativeCFunc(const FunctionSignature& func_ return RegisterFunc(func_sign, std::move(func_struct), allow_override); } +Status FunctionRegistry::RegisterCommutativeCFuncWithExecCtx(const FunctionSignature& func_sign, void* c_func_ptr, + bool allow_override) { + if (nullptr == c_func_ptr) { + return Status::InvalidArgument("c_func_ptr is nullptr"); + } + // Modern user-visible signature: no trailing kPtr; codegen auto-injects. + { + FunctionStructure func_struct; + func_struct.func_type = FunctionType::kCFunc; + func_struct.c_func_ptr = c_func_ptr; + func_struct.func_attr_setter = CommutantFunctionAttributeSetter; + func_struct.needs_exec_ctx = true; + JF_RETURN_NOT_OK(RegisterFunc(func_sign, std::move(func_struct), allow_override)); + } + // Legacy compatibility signature: with trailing kPtr; identical to the + // old RegisterCommutativeCFunc registration so existing AST/DSL code + // that still passes ExecContextNode keeps resolving. + std::vector legacy_params = func_sign.GetParamTypes(); + legacy_params.emplace_back(ValueType::kPtr); + FunctionSignature legacy_sign(func_sign.GetName(), std::move(legacy_params), func_sign.GetRetType()); + FunctionStructure legacy_struct; + legacy_struct.func_type = FunctionType::kCFunc; + legacy_struct.c_func_ptr = c_func_ptr; + legacy_struct.func_attr_setter = CommutantFunctionAttributeSetter; + legacy_struct.needs_exec_ctx = false; + return RegisterFunc(legacy_sign, std::move(legacy_struct), allow_override); +} + Status FunctionRegistry::GetFuncBySign(FunctionSignature& func_sign, FunctionStructure* func_struct) const { auto iter = signature2funcstruct_.find(func_sign); if (iter == signature2funcstruct_.end()) { @@ -177,6 +235,9 @@ Status FunctionRegistry::SetCFuncAttr(llvm::Module* m) { if (FunctionType::kLLVMIntrinicFunc == fc.func_type) { continue; } + if (fc.needs_exec_ctx) { + continue; + } auto* func = m->getFunction(sign.ToString()); if (func == nullptr) { continue; @@ -196,6 +257,9 @@ Status FunctionRegistry::MappingToJIT(llvm::orc::LLJIT* jit) { if (FunctionType::kLLVMIntrinicFunc == fc.func_type) { continue; } + if (fc.needs_exec_ctx) { + continue; + } auto function_a_address = llvm::orc::ExecutorAddr::fromPtr(fc.c_func_ptr); symbols.try_emplace(mangle(sign.ToString()), function_a_address, llvm::JITSymbolFlags::Exported); } diff --git a/test/list_group_test.cc b/test/list_group_test.cc index e6915fe..9d7c5eb 100644 --- a/test/list_group_test.cc +++ b/test/list_group_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 11:35:00 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 11:35:00 + * @Last Modified time: 2026-05-11 16:37:04 */ #include #include @@ -123,8 +123,8 @@ TEST(ListGroupTest, GroupIndexU32) { } TEST(ListGroupTest, GroupIndexU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 1, 2}; @@ -173,8 +173,7 @@ TEST(ListGroupTest, GroupIndexStringEmpty) { } TEST(ListGroupTest, GroupIndexStringWithEmptyStrings) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 2, 1, 0}; @@ -182,8 +181,8 @@ TEST(ListGroupTest, GroupIndexStringWithEmptyStrings) { } TEST(ListGroupTest, GroupIndexStringDifferentLengths) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); RetType result; ASSERT_TRUE(RunGroupIndex(MakeGroupIndexCall(std::move(list)), &result).ok()); std::vector expected = {0, 1, 0, 2, 1}; @@ -379,8 +378,8 @@ TEST(ListGroupTest, GroupKeysU32) { } TEST(ListGroupTest, GroupKeysU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; @@ -429,8 +428,7 @@ TEST(ListGroupTest, GroupKeysStringEmpty) { } TEST(ListGroupTest, GroupKeysStringWithEmptyStrings) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); + auto list = std::unique_ptr(new ConstantListValueNode(std::vector{"", "a", "", "b", "a", ""})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {"", "a", "b"}; @@ -438,8 +436,8 @@ TEST(ListGroupTest, GroupKeysStringWithEmptyStrings) { } TEST(ListGroupTest, GroupKeysStringDifferentLengths) { - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{"ab", "abc", "ab", "abcd", "abc"})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {"ab", "abc", "abcd"}; @@ -449,8 +447,8 @@ TEST(ListGroupTest, GroupKeysStringDifferentLengths) { TEST(ListGroupTest, GroupKeysPreservesFirstAppearanceOrder) { // Distinct keys must come out in the order of their first occurrence, not // sorted and not in hash-table order. - auto list = std::unique_ptr( - new ConstantListValueNode(std::vector{100, 50, 100, 75, 50, 25, 75, 100})); + auto list = + std::unique_ptr(new ConstantListValueNode(std::vector{100, 50, 100, 75, 50, 25, 75, 100})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysCall(std::move(list)), &result).ok()); std::vector expected = {100, 50, 75, 25}; @@ -461,8 +459,7 @@ TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { // keys has 4 elements, group_index has 3 -> must surface a runtime error // instead of silently truncating. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); std::vector> args; args.emplace_back(std::move(keys)); args.emplace_back(std::move(bad_group_index)); @@ -479,18 +476,17 @@ TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { namespace { -// Builds the 3-arg sugar form: GroupKeys(keys, GroupIndex(keys), exec_ctx). +// Builds the 2-arg sugar form: GroupKeys(keys, GroupIndex(keys)). // This is the user-facing call registered as an LLVM intrinsic that expands // at IR time into GroupCount + the canonical 4-arg GroupKeys kernel, letting // GVN share the distinct-count computation with other aggregates. The -// trailing exec_context keeps the call shape consistent with other DSL -// functions (GroupIndex, etc.). +// sugar lowering pulls exec_ctx from the entry function on its own, so the +// user-visible signature does not include it. std::unique_ptr MakeGroupKeysSugarCall(std::unique_ptr keys_node) { auto keys_for_index = keys_node->Clone(); std::vector> args; args.emplace_back(std::move(keys_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); } @@ -576,8 +572,8 @@ TEST(ListGroupTest, GroupKeysSugarU32) { } TEST(ListGroupTest, GroupKeysSugarU64Large) { - auto list = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); + auto list = std::unique_ptr( + new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFFULL, 1ULL, 0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL})); RetType result; ASSERT_TRUE(RunGroupKeys(MakeGroupKeysSugarCall(std::move(list)), &result).ok()); std::vector expected = {0xFFFFFFFFFFFFFFFFULL, 1ULL, 2ULL}; @@ -629,12 +625,10 @@ TEST(ListGroupTest, GroupKeysSugarLenMismatchReturnsError) { // The sugar form forwards exec_context to the 4-arg kernel, which must still // surface the same "len mismatch" runtime error path. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U})); std::vector> args; args.emplace_back(std::move(keys)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); RetType result; @@ -646,16 +640,15 @@ TEST(ListGroupTest, GroupKeysSugarLenMismatchReturnsError) { namespace { -// Builds: GroupSum(values, GroupIndex(keys), exec_ctx). Sugar form, same call -// shape as the user-facing DSL -- the IR-level expansion adds GroupCount and -// routes to the 4-arg kernel. Keys and values are separate nodes because they -// may be of different element types. +// Builds: GroupSum(values, GroupIndex(keys)). Sugar form, same call shape +// as the user-facing DSL -- the IR-level expansion adds GroupCount and +// routes to the 4-arg kernel. Keys and values are separate nodes because +// they may be of different element types. std::unique_ptr MakeGroupSumSugarCall(std::unique_ptr values_node, std::unique_ptr keys_node) { std::vector> args; args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); } @@ -705,8 +698,7 @@ TEST(ListGroupTest, GroupSumSugarI32) { TEST(ListGroupTest, GroupSumSugarI8NegativeValues) { // Exercise i8 -> i64 promotion with negative values. auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 1, 2, 1, 2})); - auto values = - std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -30, -40, 50})); + auto values = std::unique_ptr(new ConstantListValueNode(std::vector{-10, 20, -30, -40, 50})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); // group 0: -10 + 20 + (-40) = -30; group 1: -30 + 50 = 20 @@ -725,8 +717,8 @@ TEST(ListGroupTest, GroupSumSugarI16) { TEST(ListGroupTest, GroupSumSugarI64) { auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 1})); - auto values = std::unique_ptr( - new ConstantListValueNode(std::vector{1LL << 40, 1LL << 41, -(1LL << 40)})); + auto values = + std::unique_ptr(new ConstantListValueNode(std::vector{1LL << 40, 1LL << 41, -(1LL << 40)})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); std::vector expected = {0, 1LL << 41}; @@ -745,8 +737,8 @@ TEST(ListGroupTest, GroupSumSugarU8) { TEST(ListGroupTest, GroupSumSugarU64Large) { auto keys = std::unique_ptr(new ConstantListValueNode(std::vector{0, 0, 1})); - auto values = std::unique_ptr(new ConstantListValueNode( - std::vector{0xFFFFFFFFFFFFFFFEULL, 1ULL, 42ULL})); + auto values = + std::unique_ptr(new ConstantListValueNode(std::vector{0xFFFFFFFFFFFFFFFEULL, 1ULL, 42ULL})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); // Group 0 sums exactly to UINT64_MAX. @@ -810,8 +802,8 @@ TEST(ListGroupTest, GroupSumSugarStringKeys) { // keys are strings, values are numeric. GroupIndex handles the string keys; // GroupSum just operates on the resulting u32 group_index, so this exercises // the full "keys can be anything, values can be anything" combination. - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); RetType result; ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values), std::move(keys)), &result).ok()); @@ -845,10 +837,10 @@ TEST(ListGroupTest, GroupSumKernelSugarAgreeF64) { // inputs -- protects against future divergence (e.g. if sugar starts // passing a different `distinct`). auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); - auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + auto values_sugar = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); RetType sugar_result; - ASSERT_TRUE( - RunGroupSum(MakeGroupSumSugarCall(std::move(values_sugar), std::move(keys_sugar)), &sugar_result).ok()); + ASSERT_TRUE(RunGroupSum(MakeGroupSumSugarCall(std::move(values_sugar), std::move(keys_sugar)), &sugar_result).ok()); auto keys_kernel = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); auto values_kernel = @@ -871,8 +863,7 @@ TEST(ListGroupTest, GroupSumLenMismatchReturnsError) { // values has 3 elements, group_index has 4 -> kernel must surface a runtime // error, same shape as GroupKeys len-mismatch handling. auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); @@ -891,12 +882,10 @@ TEST(ListGroupTest, GroupSumSugarLenMismatchReturnsError) { // Same kind of mismatch reached through the sugar form, to prove the error // propagates across the IR-level expansion. auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); RetType result; @@ -909,14 +898,14 @@ TEST(ListGroupTest, GroupSumSugarLenMismatchReturnsError) { namespace { // Generic builder for a per-group aggregate sugar call of shape -// `(values, GroupIndex(keys), exec_ctx)`. Used by GroupMax / GroupMin -// tests and ready to be reused by later aggregates (Avg, ...). +// `(values, GroupIndex(keys))`. Used by GroupMax / GroupMin / +// GroupAvg sugars. The sugar lowering pulls exec_ctx from the entry +// function on its own, so the user-visible signature has no trailing ctx. std::unique_ptr MakeGroupAggSugarCall(const std::string &func_name, std::unique_ptr values_node, std::unique_ptr keys_node) { std::vector> args; args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } @@ -1012,8 +1001,8 @@ TEST(ListGroupTest, GroupMaxSugarEmpty) { } TEST(ListGroupTest, GroupMaxSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMax", std::move(values), std::move(keys)), &result).ok()); @@ -1087,8 +1076,8 @@ TEST(ListGroupTest, GroupMinSugarEmpty) { } TEST(ListGroupTest, GroupMinSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 7, 5, 4, 2, 3})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupMin", std::move(values), std::move(keys)), &result).ok()); @@ -1137,12 +1126,10 @@ TEST(ListGroupTest, GroupMaxMinConsistency) { TEST(ListGroupTest, GroupMaxSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupMax", std::move(args))); RetType result; @@ -1154,12 +1141,10 @@ TEST(ListGroupTest, GroupMaxSugarLenMismatchReturnsError) { TEST(ListGroupTest, GroupMinSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupMin", std::move(args))); RetType result; @@ -1197,8 +1182,8 @@ TEST(ListGroupTest, GroupAvgSugarI8NegativeValues) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 2U); - EXPECT_DOUBLE_EQ(actual[0], 5.0); // (-10 + 20) / 2 - EXPECT_DOUBLE_EQ(actual[1], -2.5); // (-3 + -2) / 2 <-- int would round to -2 + EXPECT_DOUBLE_EQ(actual[0], 5.0); // (-10 + 20) / 2 + EXPECT_DOUBLE_EQ(actual[1], -2.5); // (-3 + -2) / 2 <-- int would round to -2 } TEST(ListGroupTest, GroupAvgSugarU64) { @@ -1233,8 +1218,8 @@ TEST(ListGroupTest, GroupAvgSugarF64) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 3U); - EXPECT_DOUBLE_EQ(actual[0], 0.2); // (0.1 + 0.3) / 2 - EXPECT_DOUBLE_EQ(actual[1], 0.3); // (0.2 + 0.4) / 2 + EXPECT_DOUBLE_EQ(actual[0], 0.2); // (0.1 + 0.3) / 2 + EXPECT_DOUBLE_EQ(actual[1], 0.3); // (0.2 + 0.4) / 2 EXPECT_DOUBLE_EQ(actual[2], 0.5); } @@ -1263,7 +1248,7 @@ TEST(ListGroupTest, GroupAvgSugarAllSameGroup) { ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); auto &actual = std::get>(result); ASSERT_EQ(actual.size(), 1U); - EXPECT_DOUBLE_EQ(actual[0], 2.5); // (1+2+3+4)/4 + EXPECT_DOUBLE_EQ(actual[0], 2.5); // (1+2+3+4)/4 } TEST(ListGroupTest, GroupAvgSugarAllDistinctGroups) { @@ -1280,8 +1265,8 @@ TEST(ListGroupTest, GroupAvgSugarAllDistinctGroups) { } TEST(ListGroupTest, GroupAvgSugarStringKeys) { - auto keys = std::unique_ptr( - new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); + auto keys = + std::unique_ptr(new ConstantListValueNode(std::vector{"a", "b", "a", "c", "b", "a"})); auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3, 4, 5, 6})); RetType result; ASSERT_TRUE(RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values), std::move(keys)), &result).ok()); @@ -1311,7 +1296,8 @@ TEST(ListGroupTest, GroupAvgKernelSugarAgreeF64) { // results given identical inputs. Guards against future divergence (e.g. // sugar starting to pass a different `distinct` than GroupCount). auto keys_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{2, 2, 1, 2, 1})); - auto values_sugar = std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); + auto values_sugar = + std::unique_ptr(new ConstantListValueNode(std::vector{1.1, 2.2, 3.3, 4.4, 5.5})); RetType sugar_result; ASSERT_TRUE( RunGroupAgg(MakeGroupAggSugarCall("GroupAvg", std::move(values_sugar), std::move(keys_sugar)), &sugar_result) @@ -1359,8 +1345,7 @@ TEST(ListGroupTest, GroupAvgMatchesSumOverCount) { TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); @@ -1377,12 +1362,10 @@ TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { TEST(ListGroupTest, GroupAvgSugarLenMismatchReturnsError) { auto values = std::unique_ptr(new ConstantListValueNode(std::vector{1, 2, 3})); - auto bad_group_index = - std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); + auto bad_group_index = std::unique_ptr(new ConstantListValueNode(std::vector{0U, 1U, 0U, 1U})); std::vector> args; args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); RetType result; diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc index 4620f85..3482029 100644 --- a/test/list_indexing_test.cc +++ b/test/list_indexing_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-05-06 11:20:00 * @Last Modified by: victorika - * @Last Modified time: 2026-05-06 11:20:00 + * @Last Modified time: 2026-05-11 16:35:40 */ #include #include @@ -23,12 +23,13 @@ namespace { constexpr uint32_t kMiss = std::numeric_limits::max(); -// Build a FunctionNode that takes two lists and an ExecContextNode. +// Build a FunctionNode that takes two lists. ListLookupIndex is registered +// as a sugar lowering and its user-visible signature does NOT include the +// trailing exec_ctx; the codegen pulls ctx from the entry function itself. std::unique_ptr MakeLookup(std::unique_ptr a, std::unique_ptr b) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::make_unique()); return std::make_unique("ListLookupIndex", std::move(args)); } @@ -81,7 +82,7 @@ std::unique_ptr MakeGetAt(std::unique_ptr values, std::uniqu return std::make_unique("GetAt", std::move(args)); } -RetType RunExpr(std::unique_ptr root, Status *status_out = nullptr) { +RetType RunExpr(std::unique_ptr root, Status* status_out = nullptr) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); ExecEngine engine; diff --git a/test/list_misc_test.cc b/test/list_misc_test.cc index a742d9a..e27489e 100644 --- a/test/list_misc_test.cc +++ b/test/list_misc_test.cc @@ -26,11 +26,9 @@ TEST(FunctionTest, FilterByBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -49,11 +47,9 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -107,11 +103,10 @@ TEST(FunctionTest, FilterByBitmapSugarFromGenBitmapTest) { gen_args.emplace_back(new ExecContextNode()); auto bitmap_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(gen_args))); - // FilterByBitmap(data, bitmap, exec_ctx) -- sugar, no bits_cnt. + // FilterByBitmap(data, bitmap) -- sugar, no bits_cnt and no exec_ctx. std::vector> filter_args; filter_args.emplace_back(new ConstantListValueNode(data)); filter_args.emplace_back(std::move(bitmap_node)); - filter_args.emplace_back(new ExecContextNode()); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(filter_args))); ExecEngine exec_engine; From c88793fa724a4a72df0e6a8c15521753712e9d31 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Mon, 11 May 2026 17:02:18 +0800 Subject: [PATCH 39/41] test and benchmark remove exec_ctx node --- benchmark/bench_common.h | 24 ++++----- benchmark/bench_list_agg.cc | 16 +++--- benchmark/bench_list_basic.cc | 26 +++++----- benchmark/bench_list_compare.cc | 8 ++- benchmark/bench_list_indexing.cc | 30 ++++++------ test/empty_list_test.cc | 14 ++---- test/exec_error_test.cc | 2 - test/function_test.cc | 15 ++---- test/list_arithmetic_test.cc | 84 +++++++++++--------------------- test/list_basic_test.cc | 18 +++---- test/list_bitwise_test.cc | 36 +++++--------- test/list_cast_test.cc | 24 +++------ test/list_comparison_test.cc | 48 ++++++------------ test/list_conditional_test.cc | 33 +++++-------- test/list_group_test.cc | 26 +++------- test/list_indexing_test.cc | 10 ++-- test/list_math_test.cc | 74 ++++++++++------------------ test/list_misc_test.cc | 32 +++++------- 18 files changed, 186 insertions(+), 334 deletions(-) diff --git a/benchmark/bench_common.h b/benchmark/bench_common.h index f947ae2..514b595 100644 --- a/benchmark/bench_common.h +++ b/benchmark/bench_common.h @@ -126,8 +126,9 @@ inline std::unique_ptr MakeListUnaryCall(const std::string& func_name, // Convenience alias kept for readability. inline std::unique_ptr MakeListSumExpr(int list_len) { return MakeListUnaryCall("Sum", list_len); } -// Build `func_name(list, exec_ctx)` — one-arg list kernels that require an -// ExecContext pointer (arithmetic/basic kernels that allocate output lists). +// Build `func_name(list)` — one-arg list kernels that allocate output lists. +// (The C-level kernel still takes a trailing exec_ctx pointer; codegen now +// auto-injects it, so the user-visible AST has no ctx node.) inline std::unique_ptr MakeListUnaryCtxCall(const std::string& func_name, int list_len) { std::vector values; values.reserve(list_len); @@ -136,11 +137,10 @@ inline std::unique_ptr MakeListUnaryCtxCall(const std::string& func_na } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, exec_ctx)` — unary kernels that only accept float lists +// Build `func_name(list)` — unary kernels that only accept float lists // (ListCeil, ListFloor, ListRound). inline std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func_name, int list_len) { std::vector values; @@ -150,11 +150,10 @@ inline std::unique_ptr MakeListUnaryCtxCallF64(const std::string& func } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar_int, exec_ctx)` — list-scalar broadcast. +// Build `func_name(list, scalar_int)` — list-scalar broadcast. inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_name, int list_len, int64_t scalar_val) { std::vector values; values.reserve(list_len); @@ -164,11 +163,10 @@ inline std::unique_ptr MakeListScalarCtxCall(const std::string& func_n std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar, exec_ctx)` — bitwise list-scalar. +// Build `func_name(list, scalar)` — bitwise list-scalar. // Bitwise kernels are only registered for unsigned integer types. inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& func_name, int list_len, uint64_t scalar_val) { @@ -180,11 +178,10 @@ inline std::unique_ptr MakeListScalarCtxCallU64(const std::string& fun std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(scalar_val)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, list, exec_ctx)` — bitwise list-list. +// Build `func_name(list, list)` — bitwise list-list. inline std::unique_ptr MakeListListCtxCallU64(const std::string& func_name, int list_len) { std::vector lhs; std::vector rhs; @@ -197,11 +194,10 @@ inline std::unique_ptr MakeListListCtxCallU64(const std::string& func_ std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(lhs))); args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, list, exec_ctx)` — element-wise list-list. +// Build `func_name(list, list)` — element-wise list-list. inline std::unique_ptr MakeListListCtxCall(const std::string& func_name, int list_len) { std::vector lhs; std::vector rhs; @@ -214,11 +210,10 @@ inline std::unique_ptr MakeListListCtxCall(const std::string& func_nam std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(lhs))); args.emplace_back(new ConstantListValueNode(std::move(rhs))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build `func_name(list, scalar, scalar, exec_ctx)` — the IfEqual / +// Build `func_name(list, scalar, scalar)` — the IfEqual / // IfLess / etc. family: "for each element, if cond(elem, pivot) pick a else b". inline std::unique_ptr MakeListIfSelectCall(const std::string& func_name, int list_len) { std::vector values; @@ -230,7 +225,6 @@ inline std::unique_ptr MakeListIfSelectCall(const std::string& func_na args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(static_cast(list_len / 2))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } diff --git a/benchmark/bench_list_agg.cc b/benchmark/bench_list_agg.cc index 7afb117..705d716 100644 --- a/benchmark/bench_list_agg.cc +++ b/benchmark/bench_list_agg.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 16:07:33 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 16:07:33 + * @Last Modified time: 2026-05-11 16:58:15 */ // C. List aggregation + C-group. See bench_compile.cc for the split overview. @@ -10,15 +10,15 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeListUnaryCall; -using ::jitfusion::bench::MakeRegistry; using ::jitfusion::ConstantListValueNode; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecContext; using ::jitfusion::ExecNode; using ::jitfusion::FunctionNode; using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // C. List aggregation — kernel cost vs. list length @@ -237,12 +237,11 @@ std::unique_ptr MakeGroupKeysList(int len, int distinct) { return std::unique_ptr(new ConstantListValueNode(std::move(values))); } -// Build `GroupIndex(keys_list, exec_ctx)` — the only non-sugar group node in -// the family; its kernel is the 2-arg form. +// Build `GroupIndex(keys_list)` — the only non-sugar group node in +// the family. std::unique_ptr MakeGroupIndexNode(int len, int distinct) { std::vector> args; args.emplace_back(MakeGroupKeysList(len, distinct)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); } @@ -288,7 +287,7 @@ void BM_Execute_GroupCount(benchmark::State& state) { } BENCHMARK(BM_Execute_GroupCount)->Args({4096, 16})->Args({4096, 256})->Args({4096, 4096}); -// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...), exec_ctx)`. +// Helper: build the sugar-form call `func_name(keys_or_values, GroupIndex(...))`. // The keys list drives GroupIndex; the same list is also fed as values/keys // to the aggregate under test. That's fine because all aggregates accept // integer lists and we measure compute time, not numerical content. @@ -296,7 +295,6 @@ std::unique_ptr MakeGroupSugarCall(const std::string& func_name, int l std::vector> args; args.emplace_back(MakeGroupKeysList(len, distinct)); args.emplace_back(MakeGroupIndexNode(len, distinct)); - args.emplace_back(new jitfusion::ExecContextNode()); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } diff --git a/benchmark/bench_list_basic.cc b/benchmark/bench_list_basic.cc index f408901..33e45b7 100644 --- a/benchmark/bench_list_basic.cc +++ b/benchmark/bench_list_basic.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-30 16:07:33 * @Last Modified by: victorika - * @Last Modified time: 2026-04-30 16:07:33 + * @Last Modified time: 2026-05-11 16:58:35 */ // G. List basic (shape manipulation) + H. List element-wise unary. // See bench_compile.cc for the split overview. @@ -11,18 +11,18 @@ namespace { -using ::jitfusion::bench::CompileOrDie; -using ::jitfusion::bench::MakeListListCtxCall; -using ::jitfusion::bench::MakeListUnaryCall; -using ::jitfusion::bench::MakeListUnaryCtxCall; -using ::jitfusion::bench::MakeListUnaryCtxCallF64; -using ::jitfusion::bench::MakeRegistry; using ::jitfusion::ConstantListValueNode; using ::jitfusion::ConstantValueNode; using ::jitfusion::ExecContext; using ::jitfusion::ExecNode; using ::jitfusion::FunctionNode; using ::jitfusion::RetType; +using ::jitfusion::bench::CompileOrDie; +using ::jitfusion::bench::MakeListListCtxCall; +using ::jitfusion::bench::MakeListUnaryCall; +using ::jitfusion::bench::MakeListUnaryCtxCall; +using ::jitfusion::bench::MakeListUnaryCtxCallF64; +using ::jitfusion::bench::MakeRegistry; // ============================================================================= // G. List basic — shape-manipulation kernels @@ -163,7 +163,7 @@ void BM_Execute_ListMurmurHash3X8632(benchmark::State& state) { } BENCHMARK(BM_Execute_ListMurmurHash3X8632)->Arg(256)->Arg(4096); -// ListConcat(listA, listB, ctx). +// ListConcat(listA, listB). void BM_Execute_ListConcat(benchmark::State& state) { const int len = static_cast(state.range(0)); auto reg = MakeRegistry(); @@ -181,7 +181,7 @@ void BM_Execute_ListConcat(benchmark::State& state) { } BENCHMARK(BM_Execute_ListConcat)->Arg(256)->Arg(4096); -// CrossJoin(stringlist a, stringlist b, string sep, ctx) — produces a +// CrossJoin(stringlist a, stringlist b, string sep) — produces a // length-(|a| * |b|) stringlist of "a[i] + sep + b[j]". Output size is // quadratic in the input length, so we sweep the per-side length from 16..256 // (yielding 256..65536 output elements) instead of the usual 256/4096 sweep @@ -201,7 +201,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); args.emplace_back(new ConstantValueNode(std::string("_"))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("CrossJoin", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -218,7 +218,7 @@ void BM_Execute_CrossJoin(benchmark::State& state) { } BENCHMARK(BM_Execute_CrossJoin)->Arg(16)->Arg(64)->Arg(256); -// ZipConcat(stringlist a, stringlist b, string sep, ctx) — per-position +// ZipConcat(stringlist a, stringlist b, string sep) — per-position // concatenation, output length equals |a| (== |b|). Linear cost in input // length, so it shares the standard 256/4096 sweep with the other linear // list kernels. @@ -237,7 +237,7 @@ void BM_Execute_ZipConcat(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); args.emplace_back(new ConstantValueNode(std::string(":"))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ZipConcat", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -284,7 +284,7 @@ void BM_Execute_ListIn(benchmark::State& state) { BENCHMARK(BM_Execute_ListIn)->Arg(256)->Arg(4096); // ============================================================================= -// H. List element-wise unary (func(list, ctx) -> list) +// H. List element-wise unary (func(list) -> list) // ============================================================================= #define JITFUSION_DEFINE_LIST_UNARY_BM(NAME) \ diff --git a/benchmark/bench_list_compare.cc b/benchmark/bench_list_compare.cc index 80a7ef9..85d12f7 100644 --- a/benchmark/bench_list_compare.cc +++ b/benchmark/bench_list_compare.cc @@ -84,7 +84,7 @@ JITFUSION_DEFINE_LIST_IFSELECT_BM(IfLessEqual); #undef JITFUSION_DEFINE_LIST_IFSELECT_BM -// IfByBitmap(packed_bitmap, value_list, alt_scalar, ctx). +// IfByBitmap(packed_bitmap, value_list, alt_scalar). // For each element i: packed_bitmap bit i set ? value_list[i] : alt_scalar. // `packed_bitmap` is a U8List of ceil(len/8) bytes, LSB = first element. void BM_Execute_IfByBitmap(benchmark::State& state) { @@ -100,7 +100,6 @@ void BM_Execute_IfByBitmap(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(bitmap))); args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); std::unique_ptr node(new FunctionNode("IfByBitmap", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -117,11 +116,11 @@ void BM_Execute_IfByBitmap(benchmark::State& state) { } BENCHMARK(BM_Execute_IfByBitmap)->Arg(4096); -// FilterByBitmap(value_list, packed_bitmap, ctx) — sugar form. +// FilterByBitmap(value_list, packed_bitmap) — sugar form. // // The `packed_bitmap` is ceil(values.size() / 8) bytes; each byte encodes 8 // elements (LSB = first element). 0x55 (0b01010101) gives 4 ones per byte → -// every other element is kept. The 3-arg sugar auto-derives `bits_cnt` via +// every other element is kept. The 2-arg sugar auto-derives `bits_cnt` via // CountBits(bitmap) at codegen time, so we no longer have to precompute and // pass the popcount explicitly (and can no longer get it wrong). void BM_Execute_FilterByBitmap(benchmark::State& state) { @@ -136,7 +135,6 @@ void BM_Execute_FilterByBitmap(benchmark::State& state) { std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(bitmap))); - args.emplace_back(new jitfusion::ExecContextNode()); std::unique_ptr node(new FunctionNode("FilterByBitmap", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); diff --git a/benchmark/bench_list_indexing.cc b/benchmark/bench_list_indexing.cc index ec14f15..6b656e3 100644 --- a/benchmark/bench_list_indexing.cc +++ b/benchmark/bench_list_indexing.cc @@ -2,22 +2,22 @@ * @Author: victorika * @Date: 2026-05-06 12:48:50 * @Last Modified by: victorika - * @Last Modified time: 2026-05-06 12:48:50 + * @Last Modified time: 2026-05-11 16:58:25 */ // K. List indexing kernels: lookup / compact / gather. // // Kernel overview: -// ListLookupIndex(a, b, ctx) : for each element in a, find its first +// ListLookupIndex(a, b) : for each element in a, find its first // occurrence in b, return the position // (u32max on miss). Built on a hash // table over b. -// ListCompactPositions(raw, ctx) : given a U32 list produced by +// ListCompactPositions(raw) : given a U32 list produced by // ListLookupIndex, return the positions // in `a` that hit (i.e. the indices // themselves, filtered by "not miss"). -// ListCompactIndex(raw, ctx) : same filter, but returns the looked-up +// ListCompactIndex(raw) : same filter, but returns the looked-up // b-side indices directly. -// ListGather(values, idx, dflt, ctx) : out[k] = (idx[k] < values.len) ? +// ListGather(values, idx, dflt) : out[k] = (idx[k] < values.len) ? // values[idx[k]] : dflt. The typical // join-realign kernel. @@ -40,7 +40,7 @@ using ::jitfusion::RetType; using ::jitfusion::bench::CompileOrDie; using ::jitfusion::bench::MakeRegistry; -// Build `ListLookupIndex(a, b, ctx)` where both are i64 lists of length `len`. +// Build `ListLookupIndex(a, b)` where both are i64 lists of length `len`. // Half of a's keys hit in b (pattern chosen to exercise both hit and miss // branches of the inner loop). std::unique_ptr MakeLookupIndexCall(int len) { @@ -49,13 +49,13 @@ std::unique_ptr MakeLookupIndexCall(int len) { a.reserve(len); b.reserve(len); for (int i = 0; i < len; ++i) { - a.push_back(i); // keys 0..len-1 - b.push_back(i * 2); // keys 0,2,4,... — only even keys from a will hit + a.push_back(i); // keys 0..len-1 + b.push_back(i * 2); // keys 0,2,4,... — only even keys from a will hit } std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(a))); args.emplace_back(new ConstantListValueNode(std::move(b))); - args.emplace_back(new jitfusion::ExecContextNode()); + return std::unique_ptr(new FunctionNode("ListLookupIndex", std::move(args))); } @@ -94,7 +94,7 @@ void BM_Execute_ListCompactPositions(benchmark::State& state) { auto reg = MakeRegistry(); std::vector> args; args.emplace_back(MakeRawLookupList(len)); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactPositions", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -116,7 +116,7 @@ void BM_Execute_ListCompactIndex(benchmark::State& state) { auto reg = MakeRegistry(); std::vector> args; args.emplace_back(MakeRawLookupList(len)); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListCompactIndex", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -133,7 +133,7 @@ void BM_Execute_ListCompactIndex(benchmark::State& state) { } BENCHMARK(BM_Execute_ListCompactIndex)->Arg(256)->Arg(4096); -// ListGather(values, idx, default, ctx). `idx` is arranged so +// ListGather(values, idx, default). `idx` is arranged so // every lookup hits (j < values.len) — the common hot path. void BM_Execute_ListGather(benchmark::State& state) { const int len = static_cast(state.range(0)); @@ -150,7 +150,7 @@ void BM_Execute_ListGather(benchmark::State& state) { args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(idx))); args.emplace_back(new ConstantValueNode(static_cast(-1))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("ListGather", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); @@ -281,7 +281,7 @@ void BM_Execute_FindSorted_AllMiss(benchmark::State& state) { } BENCHMARK(BM_Execute_FindSorted_AllMiss)->Arg(256)->Arg(4096); -// Bucketize(values, boundaries, ctx). Per-element cost is +// Bucketize(values, boundaries). Per-element cost is // O(log |boundaries|), so we sweep both axes: // * values length: 256, 4096 (matches the rest of the file) // * bucket count : 16, 256 (representative for feature-engineering use) @@ -308,7 +308,7 @@ void BM_Execute_Bucketize(benchmark::State& state) { std::vector> args; args.emplace_back(new ConstantListValueNode(std::move(values))); args.emplace_back(new ConstantListValueNode(std::move(boundaries))); - args.emplace_back(new jitfusion::ExecContextNode()); + std::unique_ptr node(new FunctionNode("Bucketize", std::move(args))); auto engine = CompileOrDie(std::move(node), reg); diff --git a/test/empty_list_test.cc b/test/empty_list_test.cc index a244987..541bec2 100644 --- a/test/empty_list_test.cc +++ b/test/empty_list_test.cc @@ -35,31 +35,28 @@ Status RunExpr(std::unique_ptr expr, RetType* result) { return engine.Execute(nullptr, result); } -// Build: (, exec_ctx) for nullary-over-list ops. +// Build: () for nullary-over-list ops. std::unique_ptr MakeUnaryListCall(const std::string& func_name, std::unique_ptr list_node) { std::vector> args; args.emplace_back(std::move(list_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build: (, , exec_ctx) +// Build: (, ) std::unique_ptr MakeListScalarCall(const std::string& func_name, std::unique_ptr list_node, std::unique_ptr scalar_node) { std::vector> args; args.emplace_back(std::move(list_node)); args.emplace_back(std::move(scalar_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Build: (, , exec_ctx) for list-list ops. +// Build: (, ) for list-list ops. std::unique_ptr MakeListListCall(const std::string& func_name, std::unique_ptr lhs, std::unique_ptr rhs) { std::vector> args; args.emplace_back(std::move(lhs)); args.emplace_back(std::move(rhs)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } @@ -221,7 +218,7 @@ TEST(EmptyListRuntimeTest, GenNotEqualBitmapListEmptyVsEmpty) { // ---- list_comparison.cc: IfXxx on empty list ------------------------------- TEST(EmptyListRuntimeTest, IfLargeOnEmptyList) { - // IfLarge(list, cmp_value, target_value, exec_ctx) + // IfLarge(list, cmp_value, target_value) auto list = std::unique_ptr(new ConstantListValueNode(std::vector{})); auto cmp = std::unique_ptr(new ConstantValueNode(int32_t{5})); auto target = std::unique_ptr(new ConstantValueNode(int32_t{99})); @@ -229,7 +226,6 @@ TEST(EmptyListRuntimeTest, IfLargeOnEmptyList) { args.emplace_back(std::move(list)); args.emplace_back(std::move(cmp)); args.emplace_back(std::move(target)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("IfLarge", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); @@ -244,7 +240,6 @@ TEST(EmptyListRuntimeTest, StringConcatTwoEmptyStrings) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("StringConcat", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); @@ -257,7 +252,6 @@ TEST(EmptyListRuntimeTest, StringConcatEmptyWithNonEmpty) { std::vector> args; args.emplace_back(std::move(a)); args.emplace_back(std::move(b)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("StringConcat", std::move(args))); RetType result; ASSERT_TRUE(RunExpr(std::move(expr), &result).ok()); diff --git a/test/exec_error_test.cc b/test/exec_error_test.cc index 2d5c772..4bc2328 100644 --- a/test/exec_error_test.cc +++ b/test/exec_error_test.cc @@ -24,11 +24,9 @@ namespace { std::unique_ptr MakeListAddNode(const std::vector& lhs, const std::vector& rhs) { auto l_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto r_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args; args.emplace_back(std::move(l_node)); args.emplace_back(std::move(r_node)); - args.emplace_back(std::move(ctx_node)); return std::unique_ptr(new FunctionNode("ListAdd", std::move(args))); } diff --git a/test/function_test.cc b/test/function_test.cc index 6f7b3e3..b36e7d1 100644 --- a/test/function_test.cc +++ b/test/function_test.cc @@ -322,11 +322,10 @@ TEST(FunctionTest, StringConcatTest) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto l_node = std::unique_ptr(new ConstantValueNode(l)); auto r_node = std::unique_ptr(new ConstantValueNode(r)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(l_node)); args_list.emplace_back(std::move(r_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("StringConcat", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -449,10 +448,9 @@ TEST(FunctionTest, CastStringFromI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -467,10 +465,9 @@ TEST(FunctionTest, CastStringFromU64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -485,10 +482,9 @@ TEST(FunctionTest, CastStringFromF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -503,10 +499,9 @@ TEST(FunctionTest, CastStringFromU8Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantValueNode(arg)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastString", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_arithmetic_test.cc b/test/list_arithmetic_test.cc index e917b81..f4513ab 100644 --- a/test/list_arithmetic_test.cc +++ b/test/list_arithmetic_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListAddTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, ListAddTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, ListAddTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto add_node = std::unique_ptr(new ConstantValueNode(add)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(add_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, ListAddTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -113,11 +109,10 @@ TEST(FunctionTest, ListAddTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -135,11 +130,10 @@ TEST(FunctionTest, ListAddTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListAdd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -157,11 +151,10 @@ TEST(FunctionTest, ListSubTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -179,11 +172,10 @@ TEST(FunctionTest, ListSubTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -201,11 +193,10 @@ TEST(FunctionTest, ListSubTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto sub_node = std::unique_ptr(new ConstantValueNode(sub)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(sub_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,11 +214,10 @@ TEST(FunctionTest, ListSubTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -245,11 +235,10 @@ TEST(FunctionTest, ListSubTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -267,11 +256,10 @@ TEST(FunctionTest, ListSubTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListSub", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -289,11 +277,10 @@ TEST(FunctionTest, ListMulTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -311,11 +298,10 @@ TEST(FunctionTest, ListMulTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -333,11 +319,10 @@ TEST(FunctionTest, ListMulTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mul_node = std::unique_ptr(new ConstantValueNode(mul)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -355,11 +340,10 @@ TEST(FunctionTest, ListMulTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -377,11 +361,10 @@ TEST(FunctionTest, ListMulTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -399,11 +382,10 @@ TEST(FunctionTest, ListMulTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mul_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mul_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMul", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -421,11 +403,10 @@ TEST(FunctionTest, ListDivTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -443,11 +424,10 @@ TEST(FunctionTest, ListDivTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -465,11 +445,10 @@ TEST(FunctionTest, ListDivTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto div_node = std::unique_ptr(new ConstantValueNode(div)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -487,11 +466,10 @@ TEST(FunctionTest, ListDivTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -509,11 +487,10 @@ TEST(FunctionTest, ListDivTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -531,11 +508,10 @@ TEST(FunctionTest, ListDivTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto div_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(div_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListDiv", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -553,11 +529,10 @@ TEST(FunctionTest, ListModTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mod_node = std::unique_ptr(new ConstantValueNode(mod)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -575,11 +550,10 @@ TEST(FunctionTest, ListModTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto mod_node = std::unique_ptr(new ConstantValueNode(mod)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -597,11 +571,10 @@ TEST(FunctionTest, ListModTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mod_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -619,11 +592,10 @@ TEST(FunctionTest, ListModTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data1)); auto mod_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(mod_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMod", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_basic_test.cc b/test/list_basic_test.cc index 483da1f..5745bfa 100644 --- a/test/list_basic_test.cc +++ b/test/list_basic_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListConcatTest) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto l_node = std::unique_ptr(new ConstantListValueNode(l)); auto r_node = std::unique_ptr(new ConstantListValueNode(r)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(l_node)); args_list.emplace_back(std::move(r_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListConcat", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -80,10 +79,9 @@ TEST(FunctionTest, SortAscTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -100,10 +98,9 @@ TEST(FunctionTest, SortAscTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -120,10 +117,9 @@ TEST(FunctionTest, SortAscTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_ctx_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_ctx_node)); + auto op_node = std::unique_ptr(new FunctionNode("SortAsc", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,12 +219,11 @@ std::vector RunCrossJoin(const std::vector& a, const s auto a_node = std::unique_ptr(new ConstantListValueNode(a)); auto b_node = std::unique_ptr(new ConstantListValueNode(b)); auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(a_node)); args_list.emplace_back(std::move(b_node)); args_list.emplace_back(std::move(sep_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CrossJoin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -287,12 +282,11 @@ std::unique_ptr MakeZipConcatExpr(const std::vector& a, c auto a_node = std::unique_ptr(new ConstantListValueNode(a)); auto b_node = std::unique_ptr(new ConstantListValueNode(b)); auto sep_node = std::unique_ptr(new ConstantValueNode(sep)); - auto exec_node = std::unique_ptr(new ExecContextNode); std::vector> args_list; args_list.emplace_back(std::move(a_node)); args_list.emplace_back(std::move(b_node)); args_list.emplace_back(std::move(sep_node)); - args_list.emplace_back(std::move(exec_node)); + return std::unique_ptr(new FunctionNode("ZipConcat", std::move(args_list))); } diff --git a/test/list_bitwise_test.cc b/test/list_bitwise_test.cc index 4320dd9..50a3c63 100644 --- a/test/list_bitwise_test.cc +++ b/test/list_bitwise_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, ListBitwiseAndTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto and_data_node = std::unique_ptr(new ConstantValueNode(and_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(and_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, ListBitwiseAndTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto and_data_node = std::unique_ptr(new ConstantValueNode(and_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(and_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, ListBitwiseAndTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, ListBitwiseAndTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto data1_node = std::unique_ptr(new ConstantListValueNode(data1)); auto data2_node = std::unique_ptr(new ConstantListValueNode(data2)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(data1_node)); args_list.emplace_back(std::move(data2_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseAnd", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -114,11 +110,10 @@ TEST(FunctionTest, ListBitwiseOrTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -136,11 +131,10 @@ TEST(FunctionTest, ListBitwiseOrTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -158,11 +152,10 @@ TEST(FunctionTest, ListBitwiseOrTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantListValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -180,11 +173,10 @@ TEST(FunctionTest, ListBitwiseOrTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto or_data_node = std::unique_ptr(new ConstantListValueNode(or_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(or_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseOr", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -203,11 +195,10 @@ TEST(FunctionTest, ListBitwiseXorTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -225,11 +216,10 @@ TEST(FunctionTest, ListBitwiseXorTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -247,11 +237,10 @@ TEST(FunctionTest, ListBitwiseXorTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantListValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -269,11 +258,10 @@ TEST(FunctionTest, ListBitwiseXorTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto xor_data_node = std::unique_ptr(new ConstantListValueNode(xor_data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(xor_data_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListBitwiseXor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_cast_test.cc b/test/list_cast_test.cc index 5e0a5e9..fd8c5de 100644 --- a/test/list_cast_test.cc +++ b/test/list_cast_test.cc @@ -23,10 +23,9 @@ TEST(FunctionTest, ListCastI32ToI64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -42,10 +41,9 @@ TEST(FunctionTest, ListCastU32ToF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastF64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -61,10 +59,9 @@ TEST(FunctionTest, ListCastF32ToI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI32List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -80,10 +77,9 @@ TEST(FunctionTest, ListCastStringToI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI32List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -99,10 +95,9 @@ TEST(FunctionTest, ListCastStringToI64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastI64List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -118,10 +113,9 @@ TEST(FunctionTest, ListCastStringToU8Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastU8List", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -137,10 +131,9 @@ TEST(FunctionTest, ListCastI32ToStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastStringList", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -156,10 +149,9 @@ TEST(FunctionTest, ListCastU64ToStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("CastStringList", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_comparison_test.cc b/test/list_comparison_test.cc index cd5d38d..33394cb 100644 --- a/test/list_comparison_test.cc +++ b/test/list_comparison_test.cc @@ -25,11 +25,10 @@ TEST(FunctionTest, GenLargeBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -47,11 +46,10 @@ TEST(FunctionTest, GenLargeBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -69,11 +67,10 @@ TEST(FunctionTest, GenLargeBitmapTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -91,11 +88,10 @@ TEST(FunctionTest, GenLargeBitmapTest4) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -113,11 +109,10 @@ TEST(FunctionTest, GenLargeBitmapTest5) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -135,11 +130,10 @@ TEST(FunctionTest, GenLargeBitmapTest6) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -157,11 +151,10 @@ TEST(FunctionTest, GenLargeEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -179,11 +172,10 @@ TEST(FunctionTest, GenLargeEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLargeEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -201,11 +193,10 @@ TEST(FunctionTest, GenEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,11 +214,10 @@ TEST(FunctionTest, GenEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -245,11 +235,10 @@ TEST(FunctionTest, GenLessBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -267,11 +256,10 @@ TEST(FunctionTest, GenLessBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -289,11 +277,10 @@ TEST(FunctionTest, GenLessEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -311,11 +298,10 @@ TEST(FunctionTest, GenLessEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenLessEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -333,11 +319,10 @@ TEST(FunctionTest, GenNotEqualBitmapTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenNotEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -355,11 +340,10 @@ TEST(FunctionTest, GenNotEqualBitmapTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantListValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("GenNotEqualBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_conditional_test.cc b/test/list_conditional_test.cc index 2372539..8915479 100644 --- a/test/list_conditional_test.cc +++ b/test/list_conditional_test.cc @@ -27,12 +27,11 @@ TEST(FunctionTest, IfLargeTest1) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -52,12 +51,11 @@ TEST(FunctionTest, IfLargeTest2) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -77,12 +75,11 @@ TEST(FunctionTest, IfLargeTest3) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLarge", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -102,12 +99,11 @@ TEST(FunctionTest, IfLargeEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLargeEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -127,12 +123,11 @@ TEST(FunctionTest, IfEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -152,12 +147,11 @@ TEST(FunctionTest, IfELessTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLess", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -177,12 +171,11 @@ TEST(FunctionTest, IfELessEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfLessEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -202,12 +195,11 @@ TEST(FunctionTest, IfNotEqualTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto cmp_value_node = std::unique_ptr(new ConstantValueNode(cmp_value)); auto fill_value_node = std::unique_ptr(new ConstantValueNode(fill_value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(cmp_value_node)); args_list.emplace_back(std::move(fill_value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfNotEqual", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -228,12 +220,11 @@ TEST(FunctionTest, IfByBitmapTest1) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -256,12 +247,11 @@ TEST(FunctionTest, IfByBitmapTest2) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -285,12 +275,11 @@ TEST(FunctionTest, IfByBitmapTest3) { auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto lhs_node = std::unique_ptr(new ConstantListValueNode(lhs)); auto rhs_node = std::unique_ptr(new ConstantListValueNode(rhs)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(lhs_node)); args_list.emplace_back(std::move(rhs_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("IfByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_group_test.cc b/test/list_group_test.cc index 9d7c5eb..53ba6e3 100644 --- a/test/list_group_test.cc +++ b/test/list_group_test.cc @@ -23,7 +23,6 @@ namespace { std::unique_ptr MakeGroupIndexCall(std::unique_ptr list_node) { std::vector> args; args.emplace_back(std::move(list_node)); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupIndex", std::move(args))); } @@ -267,7 +266,7 @@ TEST(ListGroupTest, GroupCountString) { namespace { -// Builds: GroupKeys(keys, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). +// Builds: GroupKeys(keys, GroupIndex(keys), GroupCount(GroupIndex(keys))). // The keys node is cloned so the same logical list feeds every argument, // mirroring how CSE would share the GroupIndex / GroupCount sub-expressions // with other aggregates in a real pipeline. @@ -278,7 +277,6 @@ std::unique_ptr MakeGroupKeysCall(std::unique_ptr keys_node) args.emplace_back(std::move(keys_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_for_index))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); } @@ -464,7 +462,6 @@ TEST(ListGroupTest, GroupKeysLenMismatchReturnsError) { args.emplace_back(std::move(keys)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupKeys", std::move(args))); RetType result; @@ -478,10 +475,8 @@ namespace { // Builds the 2-arg sugar form: GroupKeys(keys, GroupIndex(keys)). // This is the user-facing call registered as an LLVM intrinsic that expands -// at IR time into GroupCount + the canonical 4-arg GroupKeys kernel, letting -// GVN share the distinct-count computation with other aggregates. The -// sugar lowering pulls exec_ctx from the entry function on its own, so the -// user-visible signature does not include it. +// at IR time into GroupCount + the canonical GroupKeys kernel, letting +// GVN share the distinct-count computation with other aggregates. std::unique_ptr MakeGroupKeysSugarCall(std::unique_ptr keys_node) { auto keys_for_index = keys_node->Clone(); std::vector> args; @@ -652,8 +647,8 @@ std::unique_ptr MakeGroupSumSugarCall(std::unique_ptr values return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); } -// Builds: GroupSum(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx). -// Exercises the raw 4-arg kernel directly so its contract is covered +// Builds: GroupSum(values, GroupIndex(keys), GroupCount(GroupIndex(keys))). +// Exercises the raw 3-arg kernel directly so its contract is covered // independently of the sugar-layer expansion. std::unique_ptr MakeGroupSumKernelCall(std::unique_ptr values_node, std::unique_ptr keys_node) { @@ -662,7 +657,6 @@ std::unique_ptr MakeGroupSumKernelCall(std::unique_ptr value args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); } @@ -868,7 +862,6 @@ TEST(ListGroupTest, GroupSumLenMismatchReturnsError) { args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupSum", std::move(args))); RetType result; @@ -899,8 +892,7 @@ namespace { // Generic builder for a per-group aggregate sugar call of shape // `(values, GroupIndex(keys))`. Used by GroupMax / GroupMin / -// GroupAvg sugars. The sugar lowering pulls exec_ctx from the entry -// function on its own, so the user-visible signature has no trailing ctx. +// GroupAvg sugars. std::unique_ptr MakeGroupAggSugarCall(const std::string &func_name, std::unique_ptr values_node, std::unique_ptr keys_node) { std::vector> args; @@ -909,8 +901,8 @@ std::unique_ptr MakeGroupAggSugarCall(const std::string &func_name, st return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } -// Same as above but for the raw 4-arg kernel: -// `(values, GroupIndex(keys), GroupCount(GroupIndex(keys)), exec_ctx)` +// Same as above but for the raw 3-arg kernel: +// `(values, GroupIndex(keys), GroupCount(GroupIndex(keys)))` std::unique_ptr MakeGroupAggKernelCall(const std::string &func_name, std::unique_ptr values_node, std::unique_ptr keys_node) { auto keys_for_count = keys_node->Clone(); @@ -918,7 +910,6 @@ std::unique_ptr MakeGroupAggKernelCall(const std::string &func_name, s args.emplace_back(std::move(values_node)); args.emplace_back(MakeGroupIndexCall(std::move(keys_node))); args.emplace_back(MakeGroupCountCall(std::move(keys_for_count))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); return std::unique_ptr(new FunctionNode(func_name, std::move(args))); } @@ -1350,7 +1341,6 @@ TEST(ListGroupTest, GroupAvgKernelLenMismatchReturnsError) { args.emplace_back(std::move(values)); args.emplace_back(std::move(bad_group_index)); args.emplace_back(std::unique_ptr(new ConstantValueNode(static_cast(2U)))); - args.emplace_back(std::unique_ptr(new ExecContextNode())); auto expr = std::unique_ptr(new FunctionNode("GroupAvg", std::move(args))); RetType result; diff --git a/test/list_indexing_test.cc b/test/list_indexing_test.cc index 3482029..f56945e 100644 --- a/test/list_indexing_test.cc +++ b/test/list_indexing_test.cc @@ -36,14 +36,14 @@ std::unique_ptr MakeLookup(std::unique_ptr a, std::unique_pt std::unique_ptr MakeCompactPositions(std::unique_ptr raw) { std::vector> args; args.emplace_back(std::move(raw)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactPositions", std::move(args)); } std::unique_ptr MakeCompactIndex(std::unique_ptr raw) { std::vector> args; args.emplace_back(std::move(raw)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListCompactIndex", std::move(args)); } @@ -53,7 +53,7 @@ std::unique_ptr MakeGather(std::unique_ptr values, std::uniq args.emplace_back(std::move(values)); args.emplace_back(std::move(idx)); args.emplace_back(std::move(default_value)); - args.emplace_back(std::make_unique()); + return std::make_unique("ListGather", std::move(args)); } @@ -616,13 +616,13 @@ TEST(ListIndexingTest, FindMissMatchesFindSortedMiss) { namespace { -// Build a Bucketize(values, boundaries, exec_ctx) FunctionNode. +// Build a Bucketize(values, boundaries) FunctionNode. template std::unique_ptr MakeBucketize(const std::vector& values, const std::vector& boundaries) { std::vector> args; args.emplace_back(std::make_unique(values)); args.emplace_back(std::make_unique(boundaries)); - args.emplace_back(std::make_unique()); + return std::make_unique("Bucketize", std::move(args)); } diff --git a/test/list_math_test.cc b/test/list_math_test.cc index cbececb..810b7b2 100644 --- a/test/list_math_test.cc +++ b/test/list_math_test.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2026-04-16 11:22:31 * @Last Modified by: victorika - * @Last Modified time: 2026-04-16 11:22:31 + * @Last Modified time: 2026-05-11 16:56:43 */ #include #include @@ -23,10 +23,9 @@ TEST(FunctionTest, ListExpTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -46,10 +45,9 @@ TEST(FunctionTest, ListExpTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -68,10 +66,9 @@ TEST(FunctionTest, ListExpTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListExp", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -87,10 +84,9 @@ TEST(FunctionTest, ListLogTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -107,10 +103,9 @@ TEST(FunctionTest, ListLogTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -126,10 +121,9 @@ TEST(FunctionTest, ListLogTest3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -145,10 +139,9 @@ TEST(FunctionTest, ListLog2Test1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -165,10 +158,9 @@ TEST(FunctionTest, ListLog2Test2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -184,10 +176,9 @@ TEST(FunctionTest, ListLog2Test3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog2", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -203,10 +194,9 @@ TEST(FunctionTest, ListLog10Test1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -223,10 +213,9 @@ TEST(FunctionTest, ListLog10Test2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -242,10 +231,9 @@ TEST(FunctionTest, ListLog10Test3) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListLog10", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -261,10 +249,9 @@ TEST(FunctionTest, ListCeilTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListCeil", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -282,10 +269,9 @@ TEST(FunctionTest, ListCeilTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListCeil", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -301,10 +287,9 @@ TEST(FunctionTest, ListFloorTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListFloor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -322,10 +307,9 @@ TEST(FunctionTest, ListFloorTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListFloor", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -341,10 +325,9 @@ TEST(FunctionTest, ListRoundTest1) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListRound", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -362,10 +345,9 @@ TEST(FunctionTest, ListRoundTest2) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListRound", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -383,11 +365,10 @@ TEST(FunctionTest, ListMinTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -405,11 +386,10 @@ TEST(FunctionTest, ListMinTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -427,11 +407,10 @@ TEST(FunctionTest, ListMinTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMin", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -449,11 +428,10 @@ TEST(FunctionTest, ListMaxTest1) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -471,11 +449,10 @@ TEST(FunctionTest, ListMaxTest2) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -493,11 +470,10 @@ TEST(FunctionTest, ListMaxTest3) { EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto value_node = std::unique_ptr(new ConstantValueNode(value)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(value_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("ListMax", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); diff --git a/test/list_misc_test.cc b/test/list_misc_test.cc index e27489e..c58eb9a 100644 --- a/test/list_misc_test.cc +++ b/test/list_misc_test.cc @@ -60,9 +60,9 @@ TEST(FunctionTest, FilterByBitmapTest2) { EXPECT_EQ(std::get>(result), expect); } -// Keep one test exercising the 4-arg explicit-bits_cnt kernel directly, so the +// Keep one test exercising the explicit-bits_cnt kernel directly, so the // underlying kernel (and its validation logic) stays under coverage even after -// the 3-arg sugar became the recommended path. +// the 2-arg sugar became the recommended path. TEST(FunctionTest, FilterByBitmapExplicitBitsCntTest) { std::vector data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}; @@ -72,12 +72,10 @@ TEST(FunctionTest, FilterByBitmapExplicitBitsCntTest) { auto args_node = std::unique_ptr(new ConstantListValueNode(data)); auto bitmap_node = std::unique_ptr(new ConstantListValueNode(bitmap)); auto bits_cnt_node = std::unique_ptr(new ConstantValueNode(12U)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); args_list.emplace_back(std::move(bitmap_node)); args_list.emplace_back(std::move(bits_cnt_node)); - args_list.emplace_back(std::move(exec_node)); auto op_node = std::unique_ptr(new FunctionNode("FilterByBitmap", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -96,14 +94,13 @@ TEST(FunctionTest, FilterByBitmapSugarFromGenBitmapTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); - // bitmap = GenLargeBitmap(data, 3, exec_ctx) -> keep elements > 3 + // bitmap = GenLargeBitmap(data, 3) -> keep elements > 3 std::vector> gen_args; gen_args.emplace_back(new ConstantListValueNode(data)); gen_args.emplace_back(new ConstantValueNode(static_cast(3))); - gen_args.emplace_back(new ExecContextNode()); auto bitmap_node = std::unique_ptr(new FunctionNode("GenLargeBitmap", std::move(gen_args))); - // FilterByBitmap(data, bitmap) -- sugar, no bits_cnt and no exec_ctx. + // FilterByBitmap(data, bitmap) -- sugar, no bits_cnt. std::vector> filter_args; filter_args.emplace_back(new ConstantListValueNode(data)); filter_args.emplace_back(std::move(bitmap_node)); @@ -229,10 +226,9 @@ TEST(FunctionTest, UniqueU32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -248,10 +244,9 @@ TEST(FunctionTest, UniqueI32Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -267,10 +262,9 @@ TEST(FunctionTest, UniqueF64Test) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -286,10 +280,9 @@ TEST(FunctionTest, UniqueAlreadyUniqueTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -305,10 +298,9 @@ TEST(FunctionTest, UniqueAllSameTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -324,10 +316,9 @@ TEST(FunctionTest, UniqueStringTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); @@ -343,10 +334,9 @@ TEST(FunctionTest, UniqueStringAllSameTest) { std::unique_ptr func_registry; EXPECT_TRUE(FunctionRegistryFactory::CreateFunctionRegistry(&func_registry).ok()); auto args_node = std::unique_ptr(new ConstantListValueNode(data)); - auto exec_node = std::unique_ptr(new ExecContextNode()); std::vector> args_list; args_list.emplace_back(std::move(args_node)); - args_list.emplace_back(std::move(exec_node)); + auto op_node = std::unique_ptr(new FunctionNode("Unique", std::move(args_list))); ExecEngine exec_engine; auto st = exec_engine.Compile(op_node, func_registry); From d08b2213763a1bc67250349016d28562efd8a784 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Mon, 11 May 2026 17:04:09 +0800 Subject: [PATCH 40/41] README update exec_ctx description --- README.md | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/README.md b/README.md index b72adf7..357ae92 100644 --- a/README.md +++ b/README.md @@ -124,7 +124,7 @@ I considered how many types of nodes are needed to represent a function in the e EntryArgumentNode: A node used to obtain the entry argument variables of a function. - ExecContextNode: A node used to obtain the context variables of the execution engine. + ExecContextNode: A node used to obtain the context variables of the execution engine. (Legacy — kept for backward compatibility; new code does not need to construct it explicitly because codegen auto-injects exec_ctx for functions registered via `RegisterReadOnlyCFuncWithExecCtx`.) ConstValueNode: Scalar constant node. @@ -309,9 +309,9 @@ The library is designed around a "compile once, execute from many threads" patte Recommended pattern for parallel execution: one shared `ExecEngine` plus one `ExecContext` per worker thread. # Attention -1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, you need to use the ExecContextNode. The ExecContext structure corresponding to ExecContextNode contains an arena. By using it to allocate memory, the memory will be automatically released when the execution is complete. +1. If you need to allocate memory that you cannot manage yourself and require the execution engine to manage it for you, register your C function with `RegisterReadOnlyCFuncWithExecCtx`. The function should accept a trailing `void* ctx` parameter (which is the `ExecContext` pointer); the AST does **not** pass it explicitly — codegen automatically forwards the per-execution context. The `ExecContext` carries an arena, so memory allocated through `exec_ctx->arena` is freed automatically when execution ends. -You can refer to test/exec_context_node_test.cc for more details. For example: +For example: ```c++ using namespace jitfusion; @@ -330,13 +330,14 @@ U32ListStruct CreateU32List(void* ctx) { int main() { std::unique_ptr func_registry; FunctionRegistryFactory::CreateFunctionRegistry(&func_registry); - FunctionSignature sign("create_u32_list", {ValueType::kPtr}, ValueType::kU32List); - func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(CreateU32List)); - - auto args_node = std::unique_ptr(new ExecContextNode); - std::vector> create_func_args; - create_func_args.emplace_back(std::move(args_node)); - auto create_func_node = std::unique_ptr(new FunctionNode("create_u32_list", std::move(create_func_args))); + // User-visible signature has no trailing kPtr; the trailing exec_ctx is + // injected by codegen at every call site. + FunctionSignature sign("create_u32_list", {}, ValueType::kU32List); + func_registry->RegisterReadOnlyCFuncWithExecCtx(sign, reinterpret_cast(CreateU32List)); + + // No ExecContextNode in the AST — codegen wires exec_ctx through. + auto create_func_node = std::unique_ptr( + new FunctionNode("create_u32_list", std::vector>{})); ExecEngine exec_engine; auto st = exec_engine.Compile(create_func_node, func_registry); From 387639d491396fe277c20c666a991368c1dfbbb7 Mon Sep 17 00:00:00 2001 From: weiqiangwu Date: Mon, 11 May 2026 17:09:36 +0800 Subject: [PATCH 41/41] update remove exec_ctx use --- athena/README.md | 2 +- athena/test/const_value_test.cc | 6 +- athena/test/exec_error_test.cc | 6 +- athena/test/pipeline_test.cc | 16 +- athena/test/ref_node_test.cc | 2 +- doc/function.md | 1404 +++++++++++++++---------------- src/exec_engine.cc | 2 +- 7 files changed, 719 insertions(+), 719 deletions(-) diff --git a/athena/README.md b/athena/README.md index 20b659f..c846159 100644 --- a/athena/README.md +++ b/athena/README.md @@ -38,7 +38,7 @@ when condition1 { Note: Variables modified inside `when` branches must maintain the same type as their original declaration. Nested `when` blocks are also supported. -* 5.You can obtain the input parameter pointer through the entry_arg name, access the ExecContext via exec_ctx and obtain the output parameter pointer through the output name. +* 5.You can obtain the input parameter pointer through the `entry_arg` name and the output parameter pointer through the `output` name. (The `exec_ctx` identifier is also still recognised as a legacy keyword that materialises the `ExecContext` pointer; new code does not need to pass it because functions registered via `RegisterReadOnlyCFuncWithExecCtx` get it injected by codegen.) * 6.Comments are supported in two C/C++ styles: * Line comments start with `//` and extend to the end of the line. diff --git a/athena/test/const_value_test.cc b/athena/test/const_value_test.cc index 082dd64..d46f561 100644 --- a/athena/test/const_value_test.cc +++ b/athena/test/const_value_test.cc @@ -62,9 +62,9 @@ TEST(ConstValueTest, ListMergeOptimizeTest) { std::string code = R"( a = [1, 2, 3]; b = [1, 2, 3]; - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/athena/test/exec_error_test.cc b/athena/test/exec_error_test.cc index fb584ae..3bc7896 100644 --- a/athena/test/exec_error_test.cc +++ b/athena/test/exec_error_test.cc @@ -27,7 +27,7 @@ TEST(ExecErrorTest, SingleExpressionRuntimeError) { std::string code = R"( a = [1, 2, 3]; b = [4, 5]; - r = ListAdd(a, b, exec_ctx); + r = ListAdd(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -43,7 +43,7 @@ TEST(ExecErrorTest, WithExecContextRuntimeError) { std::string code = R"( a = [1, 2, 3]; b = [4, 5]; - r = ListAdd(a, b, exec_ctx); + r = ListAdd(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); ExecContext exec_ctx(4096); @@ -74,7 +74,7 @@ TEST(ExecErrorTest, BatchExecutePartialFailure) { store(output, 0, r); )"; std::string code2 = R"( - r = ListAdd([1, 2, 3], [4, 5], exec_ctx); + r = ListAdd([1, 2, 3], [4, 5]); )"; std::string code3 = R"( a = load(entry_arg, 0); diff --git a/athena/test/pipeline_test.cc b/athena/test/pipeline_test.cc index d7bc2bf..7d75ff1 100644 --- a/athena/test/pipeline_test.cc +++ b/athena/test/pipeline_test.cc @@ -81,7 +81,7 @@ TEST(FilterTest, Test1) { EXPECT_TRUE(func_registry->RegisterReadOnlyCFunc(sign, reinterpret_cast(LoadI32List)).ok()); std::string code = R"( a = load(entry_arg, 0); - b = GenLargeBitmap(a, 3, exec_ctx); + b = GenLargeBitmap(a, 3); FilterByBitmap(a, b); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); @@ -101,7 +101,7 @@ TEST(FilterTest, Test2) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = GenLargeBitmap(a, b, exec_ctx); + c = GenLargeBitmap(a, b); FilterByBitmap(a, c); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); @@ -122,9 +122,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass1) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; @@ -143,9 +143,9 @@ TEST(CustomPassTest, CommutativeCallCanonicalizerPass2) { std::string code = R"( a = [1, 2, 3]; b = [4, 5, 6]; - c = ListAdd(a, b, exec_ctx); - d = ListAdd(b, a, exec_ctx); - e = ListAdd(c, d, exec_ctx); + c = ListAdd(a, b); + d = ListAdd(b, a); + e = ListAdd(c, d); )"; ASSERT_TRUE(athena.Compile(code, func_registry).ok()); RetType ret; diff --git a/athena/test/ref_node_test.cc b/athena/test/ref_node_test.cc index 8009d68..4b6fe30 100644 --- a/athena/test/ref_node_test.cc +++ b/athena/test/ref_node_test.cc @@ -282,7 +282,7 @@ TEST(RefNodeTest, RefNodeWithListOperations) { std::string code = R"( a = load(entry_arg, 0); b = load(entry_arg, 1); - c = ListAdd(a, b, exec_ctx); + c = ListAdd(a, b); d = Len(c); e = Len(a) + Len(b); store(output, 0, CastF32(d)); diff --git a/doc/function.md b/doc/function.md index e65094b..2ff374d 100644 --- a/doc/function.md +++ b/doc/function.md @@ -270,7 +270,7 @@ Type Conversion Functions ## StringConcat Concatenating two strings returns a new string. - string StringConcat(string lhs, string rhs, ptr exec_ctx) + string StringConcat(string lhs, string rhs) ## StringCmp Compares two strings lexicographically. The sign of the result is the sign of the difference between the values of the first pair of characters (both interpreted as unsigned char) that differ in the strings being compared. @@ -290,33 +290,33 @@ Check if the string contains the specified substring. Returns 1 if found, 0 othe ## CastString Convert numeric value to string. - string CastString(u8, ptr exec_ctx) - string CastString(i8, ptr exec_ctx) - string CastString(u16, ptr exec_ctx) - string CastString(i16, ptr exec_ctx) - string CastString(u32, ptr exec_ctx) - string CastString(i32, ptr exec_ctx) - string CastString(u64, ptr exec_ctx) - string CastString(i64, ptr exec_ctx) - string CastString(f32, ptr exec_ctx) - string CastString(f64, ptr exec_ctx) + string CastString(u8) + string CastString(i8) + string CastString(u16) + string CastString(i16) + string CastString(u32) + string CastString(i32) + string CastString(u64) + string CastString(i64) + string CastString(f32) + string CastString(f64) # List Type Functions ## ListConcat Concatenating two lists returns a new list. - u8list ListConcat(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListConcat(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListConcat(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListConcat(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListConcat(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListConcat(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListConcat(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListConcat(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListConcat(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListConcat(f64list lhs, f64list rhs, ptr exec_ctx) - stringlist ListConcat(stringlist lhs, stringlist rhs, ptr exec_ctx) + u8list ListConcat(u8list lhs, u8list rhs) + u16list ListConcat(u16list lhs, u16list rhs) + u32list ListConcat(u32list lhs, u32list rhs) + u64list ListConcat(u64list lhs, u64list rhs) + i8list ListConcat(i8list lhs, i8list rhs) + i16list ListConcat(i16list lhs, i16list rhs) + i32list ListConcat(i32list lhs, i32list rhs) + i64list ListConcat(i64list lhs, i64list rhs) + f32list ListConcat(f32list lhs, f32list rhs) + f64list ListConcat(f64list lhs, f64list rhs) + stringlist ListConcat(stringlist lhs, stringlist rhs) ## CrossJoin Cartesian-product string concatenation. Given an outer list `a`, an inner list `b` @@ -330,7 +330,7 @@ Example: `CrossJoin(["1","2","3"], ["a","b","c"], "_") == If either input list is empty, the result is empty. Numeric lists are not accepted directly — convert them to `stringlist` first via `CastStringList`. - stringlist CrossJoin(stringlist a, stringlist b, string sep, ptr exec_ctx) + stringlist CrossJoin(stringlist a, stringlist b, string sep) ## ZipConcat Per-position string concatenation. Pairs up `a[i]` with `b[i]` and produces a @@ -344,7 +344,7 @@ The two input lists must have equal length; a length mismatch is reported via Numeric lists are not accepted directly — convert them to `stringlist` first via `CastStringList`. - stringlist ZipConcat(stringlist a, stringlist b, string sep, ptr exec_ctx) + stringlist ZipConcat(stringlist a, stringlist b, string sep) ## in Check if it is in the list. @@ -477,17 +477,17 @@ Calculate the median of a pre-sorted list. For even-length lists, returns the av ## GroupIndex Assign each element in `keys` a dense group id in first-appearance order, starting from 0. Duplicate keys get the same id, so the resulting `u32list` has the same length as `keys` and is the shared input of every other `Group*` function below. - u32list GroupIndex(u8list keys, ptr exec_ctx) - u32list GroupIndex(i8list keys, ptr exec_ctx) - u32list GroupIndex(u16list keys, ptr exec_ctx) - u32list GroupIndex(i16list keys, ptr exec_ctx) - u32list GroupIndex(u32list keys, ptr exec_ctx) - u32list GroupIndex(i32list keys, ptr exec_ctx) - u32list GroupIndex(u64list keys, ptr exec_ctx) - u32list GroupIndex(i64list keys, ptr exec_ctx) - u32list GroupIndex(f32list keys, ptr exec_ctx) - u32list GroupIndex(f64list keys, ptr exec_ctx) - u32list GroupIndex(stringlist keys, ptr exec_ctx) + u32list GroupIndex(u8list keys) + u32list GroupIndex(i8list keys) + u32list GroupIndex(u16list keys) + u32list GroupIndex(i16list keys) + u32list GroupIndex(u32list keys) + u32list GroupIndex(i32list keys) + u32list GroupIndex(u64list keys) + u32list GroupIndex(i64list keys) + u32list GroupIndex(f32list keys) + u32list GroupIndex(f64list keys) + u32list GroupIndex(stringlist keys) ## GroupCount Return the number of distinct groups encoded in a `group_index` produced by `GroupIndex`. Returns 0 for empty input. @@ -495,75 +495,75 @@ Return the number of distinct groups encoded in a `group_index` produced by `Gro u32 GroupCount(u32list group_index) ## GroupKeys -Return the distinct keys in first-appearance order, one per group. The output length equals the number of distinct groups. `keys` and `group_index` must have the same length; `group_index` is typically the result of `GroupIndex(keys, exec_ctx)`. - - u8list GroupKeys(u8list keys, u32list group_index, ptr exec_ctx) - i8list GroupKeys(i8list keys, u32list group_index, ptr exec_ctx) - u16list GroupKeys(u16list keys, u32list group_index, ptr exec_ctx) - i16list GroupKeys(i16list keys, u32list group_index, ptr exec_ctx) - u32list GroupKeys(u32list keys, u32list group_index, ptr exec_ctx) - i32list GroupKeys(i32list keys, u32list group_index, ptr exec_ctx) - u64list GroupKeys(u64list keys, u32list group_index, ptr exec_ctx) - i64list GroupKeys(i64list keys, u32list group_index, ptr exec_ctx) - f32list GroupKeys(f32list keys, u32list group_index, ptr exec_ctx) - f64list GroupKeys(f64list keys, u32list group_index, ptr exec_ctx) - stringlist GroupKeys(stringlist keys, u32list group_index, ptr exec_ctx) +Return the distinct keys in first-appearance order, one per group. The output length equals the number of distinct groups. `keys` and `group_index` must have the same length; `group_index` is typically the result of `GroupIndex(keys)`. + + u8list GroupKeys(u8list keys, u32list group_index) + i8list GroupKeys(i8list keys, u32list group_index) + u16list GroupKeys(u16list keys, u32list group_index) + i16list GroupKeys(i16list keys, u32list group_index) + u32list GroupKeys(u32list keys, u32list group_index) + i32list GroupKeys(i32list keys, u32list group_index) + u64list GroupKeys(u64list keys, u32list group_index) + i64list GroupKeys(i64list keys, u32list group_index) + f32list GroupKeys(f32list keys, u32list group_index) + f64list GroupKeys(f64list keys, u32list group_index) + stringlist GroupKeys(stringlist keys, u32list group_index) ## GroupSum Per-group sum of `values`. The output has one entry per distinct group, in the same order as `GroupKeys`. Signed integers promote to `i64`, unsigned to `u64`, floats to `f64` — matching the ungrouped `Sum`. `values.len` must equal `group_index.len`. - i64list GroupSum(i8list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i16list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i32list values, u32list group_index, ptr exec_ctx) - i64list GroupSum(i64list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u8list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u16list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u32list values, u32list group_index, ptr exec_ctx) - u64list GroupSum(u64list values, u32list group_index, ptr exec_ctx) - f64list GroupSum(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupSum(f64list values, u32list group_index, ptr exec_ctx) + i64list GroupSum(i8list values, u32list group_index) + i64list GroupSum(i16list values, u32list group_index) + i64list GroupSum(i32list values, u32list group_index) + i64list GroupSum(i64list values, u32list group_index) + u64list GroupSum(u8list values, u32list group_index) + u64list GroupSum(u16list values, u32list group_index) + u64list GroupSum(u32list values, u32list group_index) + u64list GroupSum(u64list values, u32list group_index) + f64list GroupSum(f32list values, u32list group_index) + f64list GroupSum(f64list values, u32list group_index) ## GroupMax Per-group maximum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Max`). `values.len` must equal `group_index.len`. - u8list GroupMax(u8list values, u32list group_index, ptr exec_ctx) - i8list GroupMax(i8list values, u32list group_index, ptr exec_ctx) - u16list GroupMax(u16list values, u32list group_index, ptr exec_ctx) - i16list GroupMax(i16list values, u32list group_index, ptr exec_ctx) - u32list GroupMax(u32list values, u32list group_index, ptr exec_ctx) - i32list GroupMax(i32list values, u32list group_index, ptr exec_ctx) - u64list GroupMax(u64list values, u32list group_index, ptr exec_ctx) - i64list GroupMax(i64list values, u32list group_index, ptr exec_ctx) - f32list GroupMax(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupMax(f64list values, u32list group_index, ptr exec_ctx) + u8list GroupMax(u8list values, u32list group_index) + i8list GroupMax(i8list values, u32list group_index) + u16list GroupMax(u16list values, u32list group_index) + i16list GroupMax(i16list values, u32list group_index) + u32list GroupMax(u32list values, u32list group_index) + i32list GroupMax(i32list values, u32list group_index) + u64list GroupMax(u64list values, u32list group_index) + i64list GroupMax(i64list values, u32list group_index) + f32list GroupMax(f32list values, u32list group_index) + f64list GroupMax(f64list values, u32list group_index) ## GroupMin Per-group minimum of `values`. Output type matches the input element type (no promotion, same rule as the ungrouped `Min`). `values.len` must equal `group_index.len`. - u8list GroupMin(u8list values, u32list group_index, ptr exec_ctx) - i8list GroupMin(i8list values, u32list group_index, ptr exec_ctx) - u16list GroupMin(u16list values, u32list group_index, ptr exec_ctx) - i16list GroupMin(i16list values, u32list group_index, ptr exec_ctx) - u32list GroupMin(u32list values, u32list group_index, ptr exec_ctx) - i32list GroupMin(i32list values, u32list group_index, ptr exec_ctx) - u64list GroupMin(u64list values, u32list group_index, ptr exec_ctx) - i64list GroupMin(i64list values, u32list group_index, ptr exec_ctx) - f32list GroupMin(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupMin(f64list values, u32list group_index, ptr exec_ctx) + u8list GroupMin(u8list values, u32list group_index) + i8list GroupMin(i8list values, u32list group_index) + u16list GroupMin(u16list values, u32list group_index) + i16list GroupMin(i16list values, u32list group_index) + u32list GroupMin(u32list values, u32list group_index) + i32list GroupMin(i32list values, u32list group_index) + u64list GroupMin(u64list values, u32list group_index) + i64list GroupMin(i64list values, u32list group_index) + f32list GroupMin(f32list values, u32list group_index) + f64list GroupMin(f64list values, u32list group_index) ## GroupAvg Per-group average of `values`. Output is always `f64list` with one entry per distinct group, matching the ungrouped `Avg`. `values.len` must equal `group_index.len`. - f64list GroupAvg(u8list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i8list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u16list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i16list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(u64list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(i64list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(f32list values, u32list group_index, ptr exec_ctx) - f64list GroupAvg(f64list values, u32list group_index, ptr exec_ctx) + f64list GroupAvg(u8list values, u32list group_index) + f64list GroupAvg(i8list values, u32list group_index) + f64list GroupAvg(u16list values, u32list group_index) + f64list GroupAvg(i16list values, u32list group_index) + f64list GroupAvg(u32list values, u32list group_index) + f64list GroupAvg(i32list values, u32list group_index) + f64list GroupAvg(u64list values, u32list group_index) + f64list GroupAvg(i64list values, u32list group_index) + f64list GroupAvg(f32list values, u32list group_index) + f64list GroupAvg(f64list values, u32list group_index) ## GetAt Get the element at the specified index from the list. Returns the default value (0 for numeric types) if the index is out of bounds. @@ -582,45 +582,45 @@ Get the element at the specified index from the list. Returns the default value ## Unique Remove duplicate elements from the list while preserving the original order. Returns a new list containing only the first occurrence of each element. - u8list Unique(u8list src, ptr exec_ctx) - u16list Unique(u16list src, ptr exec_ctx) - u32list Unique(u32list src, ptr exec_ctx) - u64list Unique(u64list src, ptr exec_ctx) - i8list Unique(i8list src, ptr exec_ctx) - i16list Unique(i16list src, ptr exec_ctx) - i32list Unique(i32list src, ptr exec_ctx) - i64list Unique(i64list src, ptr exec_ctx) - f32list Unique(f32list src, ptr exec_ctx) - f64list Unique(f64list src, ptr exec_ctx) - stringlist Unique(stringlist src, ptr exec_ctx) + u8list Unique(u8list src) + u16list Unique(u16list src) + u32list Unique(u32list src) + u64list Unique(u64list src) + i8list Unique(i8list src) + i16list Unique(i16list src) + i32list Unique(i32list src) + i64list Unique(i64list src) + f32list Unique(f32list src) + f64list Unique(f64list src) + stringlist Unique(stringlist src) ## SortAsc Return the sorted list in ascending order. - u8list SortAsc(u8list unsorted, ptr exec_ctx) - u16list SortAsc(u16list unsorted, ptr exec_ctx) - u32list SortAsc(u32list unsorted, ptr exec_ctx) - u64list SortAsc(u64list unsorted, ptr exec_ctx) - i8list SortAsc(i8list unsorted, ptr exec_ctx) - i16list SortAsc(i16list unsorted, ptr exec_ctx) - i32list SortAsc(i32list unsorted, ptr exec_ctx) - i64list SortAsc(i64list unsorted, ptr exec_ctx) - f32list SortAsc(f32list unsorted, ptr exec_ctx) - f64list SortAsc(f64list unsorted, ptr exec_ctx) + u8list SortAsc(u8list unsorted) + u16list SortAsc(u16list unsorted) + u32list SortAsc(u32list unsorted) + u64list SortAsc(u64list unsorted) + i8list SortAsc(i8list unsorted) + i16list SortAsc(i16list unsorted) + i32list SortAsc(i32list unsorted) + i64list SortAsc(i64list unsorted) + f32list SortAsc(f32list unsorted) + f64list SortAsc(f64list unsorted) ## SortDesc Return the sorted list in descending order. - u8list SortDesc(u8list unsorted, ptr exec_ctx) - u16list SortDesc(u16list unsorted, ptr exec_ctx) - u32list SortDesc(u32list unsorted, ptr exec_ctx) - u64list SortDesc(u64list unsorted, ptr exec_ctx) - i8list SortDesc(i8list unsorted, ptr exec_ctx) - i16list SortDesc(i16list unsorted, ptr exec_ctx) - i32list SortDesc(i32list unsorted, ptr exec_ctx) - i64list SortDesc(i64list unsorted, ptr exec_ctx) - f32list SortDesc(f32list unsorted, ptr exec_ctx) - f64list SortDesc(f64list unsorted, ptr exec_ctx) + u8list SortDesc(u8list unsorted) + u16list SortDesc(u16list unsorted) + u32list SortDesc(u32list unsorted) + u64list SortDesc(u64list unsorted) + i8list SortDesc(i8list unsorted) + i16list SortDesc(i16list unsorted) + i32list SortDesc(i32list unsorted) + i64list SortDesc(i64list unsorted) + f32list SortDesc(f32list unsorted) + f64list SortDesc(f64list unsorted) ## Truncate Return the truncated list. @@ -640,480 +640,480 @@ Return the truncated list. ## ListAdd Return a new list after adding a number to all elements in the list. - u8list ListAdd(u8list src, u8 add, ptr exec_ctx) - u16list ListAdd(u16list src, u16 add, ptr exec_ctx) - u32list ListAdd(u32list src, u32 add, ptr exec_ctx) - u64list ListAdd(u64list src, u64 add, ptr exec_ctx) - i8list ListAdd(i8list src, i8 add, ptr exec_ctx) - i16list ListAdd(i16list src, i16 add, ptr exec_ctx) - i32list ListAdd(i32list src, i32 add, ptr exec_ctx) - i64list ListAdd(i64list src, i64 add, ptr exec_ctx) - f32list ListAdd(f32list src, f32 add, ptr exec_ctx) - f64list ListAdd(f64list src, f64 add, ptr exec_ctx) + u8list ListAdd(u8list src, u8 add) + u16list ListAdd(u16list src, u16 add) + u32list ListAdd(u32list src, u32 add) + u64list ListAdd(u64list src, u64 add) + i8list ListAdd(i8list src, i8 add) + i16list ListAdd(i16list src, i16 add) + i32list ListAdd(i32list src, i32 add) + i64list ListAdd(i64list src, i64 add) + f32list ListAdd(f32list src, f32 add) + f64list ListAdd(f64list src, f64 add) Add two lists element-wise and return a new list. Both lists must have equal length. - u8list ListAdd(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListAdd(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListAdd(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListAdd(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListAdd(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListAdd(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListAdd(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListAdd(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListAdd(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListAdd(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListAdd(u8list lhs, u8list rhs) + u16list ListAdd(u16list lhs, u16list rhs) + u32list ListAdd(u32list lhs, u32list rhs) + u64list ListAdd(u64list lhs, u64list rhs) + i8list ListAdd(i8list lhs, i8list rhs) + i16list ListAdd(i16list lhs, i16list rhs) + i32list ListAdd(i32list lhs, i32list rhs) + i64list ListAdd(i64list lhs, i64list rhs) + f32list ListAdd(f32list lhs, f32list rhs) + f64list ListAdd(f64list lhs, f64list rhs) ## ListSub Return a new list after subtracting a number to all elements in the list. - u8list ListSub(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListSub(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListSub(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListSub(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListSub(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListSub(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListSub(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListSub(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListSub(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListSub(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListSub(u8list lhs, u8 rhs) + u16list ListSub(u16list lhs, u16 rhs) + u32list ListSub(u32list lhs, u32 rhs) + u64list ListSub(u64list lhs, u64 rhs) + i8list ListSub(i8list lhs, i8 rhs) + i16list ListSub(i16list lhs, i16 rhs) + i32list ListSub(i32list lhs, i32 rhs) + i64list ListSub(i64list lhs, i64 rhs) + f32list ListSub(f32list lhs, f32 rhs) + f64list ListSub(f64list lhs, f64 rhs) Subtract two lists element-wise and return a new list. Both lists must have equal length. - u8list ListSub(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListSub(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListSub(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListSub(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListSub(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListSub(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListSub(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListSub(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListSub(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListSub(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListSub(u8list lhs, u8list rhs) + u16list ListSub(u16list lhs, u16list rhs) + u32list ListSub(u32list lhs, u32list rhs) + u64list ListSub(u64list lhs, u64list rhs) + i8list ListSub(i8list lhs, i8list rhs) + i16list ListSub(i16list lhs, i16list rhs) + i32list ListSub(i32list lhs, i32list rhs) + i64list ListSub(i64list lhs, i64list rhs) + f32list ListSub(f32list lhs, f32list rhs) + f64list ListSub(f64list lhs, f64list rhs) ## ListMul Return a new list after multiplying all elements in the list by a number. - u8list ListMul(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMul(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMul(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMul(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMul(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMul(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMul(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMul(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMul(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMul(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMul(u8list lhs, u8 rhs) + u16list ListMul(u16list lhs, u16 rhs) + u32list ListMul(u32list lhs, u32 rhs) + u64list ListMul(u64list lhs, u64 rhs) + i8list ListMul(i8list lhs, i8 rhs) + i16list ListMul(i16list lhs, i16 rhs) + i32list ListMul(i32list lhs, i32 rhs) + i64list ListMul(i64list lhs, i64 rhs) + f32list ListMul(f32list lhs, f32 rhs) + f64list ListMul(f64list lhs, f64 rhs) Multiply two lists element-wise and return a new list. Both lists must have equal length. - u8list ListMul(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListMul(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListMul(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListMul(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListMul(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListMul(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListMul(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListMul(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListMul(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListMul(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListMul(u8list lhs, u8list rhs) + u16list ListMul(u16list lhs, u16list rhs) + u32list ListMul(u32list lhs, u32list rhs) + u64list ListMul(u64list lhs, u64list rhs) + i8list ListMul(i8list lhs, i8list rhs) + i16list ListMul(i16list lhs, i16list rhs) + i32list ListMul(i32list lhs, i32list rhs) + i64list ListMul(i64list lhs, i64list rhs) + f32list ListMul(f32list lhs, f32list rhs) + f64list ListMul(f64list lhs, f64list rhs) ## ListDiv Return a new list after dividing all elements in the list by a given number. - u8list ListDiv(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListDiv(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListDiv(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListDiv(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListDiv(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListDiv(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListDiv(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListDiv(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListDiv(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListDiv(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListDiv(u8list lhs, u8 rhs) + u16list ListDiv(u16list lhs, u16 rhs) + u32list ListDiv(u32list lhs, u32 rhs) + u64list ListDiv(u64list lhs, u64 rhs) + i8list ListDiv(i8list lhs, i8 rhs) + i16list ListDiv(i16list lhs, i16 rhs) + i32list ListDiv(i32list lhs, i32 rhs) + i64list ListDiv(i64list lhs, i64 rhs) + f32list ListDiv(f32list lhs, f32 rhs) + f64list ListDiv(f64list lhs, f64 rhs) Divide two lists element-wise and return a new list. Both lists must have equal length. - u8list ListDiv(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListDiv(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListDiv(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListDiv(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListDiv(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListDiv(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListDiv(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListDiv(i64list lhs, i64list rhs, ptr exec_ctx) - f32list ListDiv(f32list lhs, f32list rhs, ptr exec_ctx) - f64list ListDiv(f64list lhs, f64list rhs, ptr exec_ctx) + u8list ListDiv(u8list lhs, u8list rhs) + u16list ListDiv(u16list lhs, u16list rhs) + u32list ListDiv(u32list lhs, u32list rhs) + u64list ListDiv(u64list lhs, u64list rhs) + i8list ListDiv(i8list lhs, i8list rhs) + i16list ListDiv(i16list lhs, i16list rhs) + i32list ListDiv(i32list lhs, i32list rhs) + i64list ListDiv(i64list lhs, i64list rhs) + f32list ListDiv(f32list lhs, f32list rhs) + f64list ListDiv(f64list lhs, f64list rhs) ## ListMod Return a new list after applying the modulus operation to all elements in the list with a given number. - u8list ListMod(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMod(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMod(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMod(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMod(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMod(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMod(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMod(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListMod(u8list lhs, u8 rhs) + u16list ListMod(u16list lhs, u16 rhs) + u32list ListMod(u32list lhs, u32 rhs) + u64list ListMod(u64list lhs, u64 rhs) + i8list ListMod(i8list lhs, i8 rhs) + i16list ListMod(i16list lhs, i16 rhs) + i32list ListMod(i32list lhs, i32 rhs) + i64list ListMod(i64list lhs, i64 rhs) Apply the modulus operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListMod(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListMod(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListMod(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListMod(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListMod(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListMod(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListMod(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListMod(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListMod(u8list lhs, u8list rhs) + u16list ListMod(u16list lhs, u16list rhs) + u32list ListMod(u32list lhs, u32list rhs) + u64list ListMod(u64list lhs, u64list rhs) + i8list ListMod(i8list lhs, i8list rhs) + i16list ListMod(i16list lhs, i16list rhs) + i32list ListMod(i32list lhs, i32list rhs) + i64list ListMod(i64list lhs, i64list rhs) ## ListBitwiseAnd Return a new list after performing a bitwise AND operation between all elements in the list and a given number. - u8list ListBitwiseAnd(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseAnd(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseAnd(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseAnd(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseAnd(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseAnd(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseAnd(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseAnd(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseAnd(u8list lhs, u8 rhs) + u16list ListBitwiseAnd(u16list lhs, u16 rhs) + u32list ListBitwiseAnd(u32list lhs, u32 rhs) + u64list ListBitwiseAnd(u64list lhs, u64 rhs) + i8list ListBitwiseAnd(i8list lhs, i8 rhs) + i16list ListBitwiseAnd(i16list lhs, i16 rhs) + i32list ListBitwiseAnd(i32list lhs, i32 rhs) + i64list ListBitwiseAnd(i64list lhs, i64 rhs) Perform a bitwise AND operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseAnd(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseAnd(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseAnd(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseAnd(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseAnd(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseAnd(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseAnd(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseAnd(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseAnd(u8list lhs, u8list rhs) + u16list ListBitwiseAnd(u16list lhs, u16list rhs) + u32list ListBitwiseAnd(u32list lhs, u32list rhs) + u64list ListBitwiseAnd(u64list lhs, u64list rhs) + i8list ListBitwiseAnd(i8list lhs, i8list rhs) + i16list ListBitwiseAnd(i16list lhs, i16list rhs) + i32list ListBitwiseAnd(i32list lhs, i32list rhs) + i64list ListBitwiseAnd(i64list lhs, i64list rhs) ## ListBitwiseOr Return a new list after performing a bitwise OR operation between all elements in the list and a given number. - u8list ListBitwiseOr(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseOr(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseOr(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseOr(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseOr(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseOr(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseOr(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseOr(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseOr(u8list lhs, u8 rhs) + u16list ListBitwiseOr(u16list lhs, u16 rhs) + u32list ListBitwiseOr(u32list lhs, u32 rhs) + u64list ListBitwiseOr(u64list lhs, u64 rhs) + i8list ListBitwiseOr(i8list lhs, i8 rhs) + i16list ListBitwiseOr(i16list lhs, i16 rhs) + i32list ListBitwiseOr(i32list lhs, i32 rhs) + i64list ListBitwiseOr(i64list lhs, i64 rhs) Perform a bitwise OR operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseOr(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseOr(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseOr(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseOr(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseOr(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseOr(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseOr(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseOr(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseOr(u8list lhs, u8list rhs) + u16list ListBitwiseOr(u16list lhs, u16list rhs) + u32list ListBitwiseOr(u32list lhs, u32list rhs) + u64list ListBitwiseOr(u64list lhs, u64list rhs) + i8list ListBitwiseOr(i8list lhs, i8list rhs) + i16list ListBitwiseOr(i16list lhs, i16list rhs) + i32list ListBitwiseOr(i32list lhs, i32list rhs) + i64list ListBitwiseOr(i64list lhs, i64list rhs) ## ListBitwiseXor Return a new list after performing a bitwise XOR operation between all elements in the list and a given number. - u8list ListBitwiseXor(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListBitwiseXor(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListBitwiseXor(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListBitwiseXor(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListBitwiseXor(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListBitwiseXor(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListBitwiseXor(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListBitwiseXor(i64list lhs, i64 rhs, ptr exec_ctx) + u8list ListBitwiseXor(u8list lhs, u8 rhs) + u16list ListBitwiseXor(u16list lhs, u16 rhs) + u32list ListBitwiseXor(u32list lhs, u32 rhs) + u64list ListBitwiseXor(u64list lhs, u64 rhs) + i8list ListBitwiseXor(i8list lhs, i8 rhs) + i16list ListBitwiseXor(i16list lhs, i16 rhs) + i32list ListBitwiseXor(i32list lhs, i32 rhs) + i64list ListBitwiseXor(i64list lhs, i64 rhs) Perform a bitwise XOR operation element-wise on two lists and return a new list. Both lists must have equal length. - u8list ListBitwiseXor(u8list lhs, u8list rhs, ptr exec_ctx) - u16list ListBitwiseXor(u16list lhs, u16list rhs, ptr exec_ctx) - u32list ListBitwiseXor(u32list lhs, u32list rhs, ptr exec_ctx) - u64list ListBitwiseXor(u64list lhs, u64list rhs, ptr exec_ctx) - i8list ListBitwiseXor(i8list lhs, i8list rhs, ptr exec_ctx) - i16list ListBitwiseXor(i16list lhs, i16list rhs, ptr exec_ctx) - i32list ListBitwiseXor(i32list lhs, i32list rhs, ptr exec_ctx) - i64list ListBitwiseXor(i64list lhs, i64list rhs, ptr exec_ctx) + u8list ListBitwiseXor(u8list lhs, u8list rhs) + u16list ListBitwiseXor(u16list lhs, u16list rhs) + u32list ListBitwiseXor(u32list lhs, u32list rhs) + u64list ListBitwiseXor(u64list lhs, u64list rhs) + i8list ListBitwiseXor(i8list lhs, i8list rhs) + i16list ListBitwiseXor(i16list lhs, i16list rhs) + i32list ListBitwiseXor(i32list lhs, i32list rhs) + i64list ListBitwiseXor(i64list lhs, i64list rhs) ## ListExp Return a new list after performing the exp operation on all elements in the list. - f64list ListExp(u8list src, ptr exec_ctx) - f64list ListExp(u16list src, ptr exec_ctx) - f64list ListExp(u32list src, ptr exec_ctx) - f64list ListExp(u64list src, ptr exec_ctx) - f64list ListExp(i8list src, ptr exec_ctx) - f64list ListExp(i16list src, ptr exec_ctx) - f64list ListExp(i32list src, ptr exec_ctx) - f64list ListExp(i64list src, ptr exec_ctx) - f32list ListExp(f32list src, ptr exec_ctx) - f64list ListExp(f64list src, ptr exec_ctx) + f64list ListExp(u8list src) + f64list ListExp(u16list src) + f64list ListExp(u32list src) + f64list ListExp(u64list src) + f64list ListExp(i8list src) + f64list ListExp(i16list src) + f64list ListExp(i32list src) + f64list ListExp(i64list src) + f32list ListExp(f32list src) + f64list ListExp(f64list src) ## ListLog Return a new list after performing the log operation on all elements in the list. - f64list ListLog(u8list src, ptr exec_ctx) - f64list ListLog(u16list src, ptr exec_ctx) - f64list ListLog(u32list src, ptr exec_ctx) - f64list ListLog(u64list src, ptr exec_ctx) - f64list ListLog(i8list src, ptr exec_ctx) - f64list ListLog(i16list src, ptr exec_ctx) - f64list ListLog(i32list src, ptr exec_ctx) - f64list ListLog(i64list src, ptr exec_ctx) - f32list ListLog(f32list src, ptr exec_ctx) - f64list ListLog(f64list src, ptr exec_ctx) + f64list ListLog(u8list src) + f64list ListLog(u16list src) + f64list ListLog(u32list src) + f64list ListLog(u64list src) + f64list ListLog(i8list src) + f64list ListLog(i16list src) + f64list ListLog(i32list src) + f64list ListLog(i64list src) + f32list ListLog(f32list src) + f64list ListLog(f64list src) ## ListLog2 Return a new list after performing the log2 operation on all elements in the list. - f64list ListLog2(u8list src, ptr exec_ctx) - f64list ListLog2(u16list src, ptr exec_ctx) - f64list ListLog2(u32list src, ptr exec_ctx) - f64list ListLog2(u64list src, ptr exec_ctx) - f64list ListLog2(i8list src, ptr exec_ctx) - f64list ListLog2(i16list src, ptr exec_ctx) - f64list ListLog2(i32list src, ptr exec_ctx) - f64list ListLog2(i64list src, ptr exec_ctx) - f32list ListLog2(f32list src, ptr exec_ctx) - f64list ListLog2(f64list src, ptr exec_ctx) + f64list ListLog2(u8list src) + f64list ListLog2(u16list src) + f64list ListLog2(u32list src) + f64list ListLog2(u64list src) + f64list ListLog2(i8list src) + f64list ListLog2(i16list src) + f64list ListLog2(i32list src) + f64list ListLog2(i64list src) + f32list ListLog2(f32list src) + f64list ListLog2(f64list src) ## ListLog10 Return a new list after performing the log10 operation on all elements in the list. - f64list ListLog10(u8list src, ptr exec_ctx) - f64list ListLog10(u16list src, ptr exec_ctx) - f64list ListLog10(u32list src, ptr exec_ctx) - f64list ListLog10(u64list src, ptr exec_ctx) - f64list ListLog10(i8list src, ptr exec_ctx) - f64list ListLog10(i16list src, ptr exec_ctx) - f64list ListLog10(i32list src, ptr exec_ctx) - f64list ListLog10(i64list src, ptr exec_ctx) - f32list ListLog10(f32list src, ptr exec_ctx) - f64list ListLog10(f64list src, ptr exec_ctx) + f64list ListLog10(u8list src) + f64list ListLog10(u16list src) + f64list ListLog10(u32list src) + f64list ListLog10(u64list src) + f64list ListLog10(i8list src) + f64list ListLog10(i16list src) + f64list ListLog10(i32list src) + f64list ListLog10(i64list src) + f32list ListLog10(f32list src) + f64list ListLog10(f64list src) ## ListCeil Return a new list after performing the ceil operation on all elements in the list. - f32list ListCeil(f32list src, ptr exec_ctx) - f64list ListCeil(f64list src, ptr exec_ctx) + f32list ListCeil(f32list src) + f64list ListCeil(f64list src) ## ListFloor Return a new list after performing the floor operation on all elements in the list. - f32list ListFloor(f32list src, ptr exec_ctx) - f64list ListFloor(f64list src, ptr exec_ctx) + f32list ListFloor(f32list src) + f64list ListFloor(f64list src) ## ListRound Return a new list after performing the round operation on all elements in the list. - f32list ListRound(f32list src, ptr exec_ctx) - f64list ListRound(f64list src, ptr exec_ctx) + f32list ListRound(f32list src) + f64list ListRound(f64list src) ## ListMin Return a new list after performing the min operation between each element in the list and a given number. - u8list ListMin(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMin(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMin(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMin(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMin(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMin(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMin(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMin(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMin(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMin(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMin(u8list lhs, u8 rhs) + u16list ListMin(u16list lhs, u16 rhs) + u32list ListMin(u32list lhs, u32 rhs) + u64list ListMin(u64list lhs, u64 rhs) + i8list ListMin(i8list lhs, i8 rhs) + i16list ListMin(i16list lhs, i16 rhs) + i32list ListMin(i32list lhs, i32 rhs) + i64list ListMin(i64list lhs, i64 rhs) + f32list ListMin(f32list lhs, f32 rhs) + f64list ListMin(f64list lhs, f64 rhs) ## ListMax Return a new list after performing the max operation between each element in the list and a given number. - u8list ListMax(u8list lhs, u8 rhs, ptr exec_ctx) - u16list ListMax(u16list lhs, u16 rhs, ptr exec_ctx) - u32list ListMax(u32list lhs, u32 rhs, ptr exec_ctx) - u64list ListMax(u64list lhs, u64 rhs, ptr exec_ctx) - i8list ListMax(i8list lhs, i8 rhs, ptr exec_ctx) - i16list ListMax(i16list lhs, i16 rhs, ptr exec_ctx) - i32list ListMax(i32list lhs, i32 rhs, ptr exec_ctx) - i64list ListMax(i64list lhs, i64 rhs, ptr exec_ctx) - f32list ListMax(f32list lhs, f32 rhs, ptr exec_ctx) - f64list ListMax(f64list lhs, f64 rhs, ptr exec_ctx) + u8list ListMax(u8list lhs, u8 rhs) + u16list ListMax(u16list lhs, u16 rhs) + u32list ListMax(u32list lhs, u32 rhs) + u64list ListMax(u64list lhs, u64 rhs) + i8list ListMax(i8list lhs, i8 rhs) + i16list ListMax(i16list lhs, i16 rhs) + i32list ListMax(i32list lhs, i32 rhs) + i64list ListMax(i64list lhs, i64 rhs) + f32list ListMax(f32list lhs, f32 rhs) + f64list ListMax(f64list lhs, f64 rhs) ## GenLargeBitmap Return a bitmap representation after performing a greater-than comparison on all elements in the list. - u8list GenLargeBitmap(u8list, u8, ptr exec_ctx) - u8list GenLargeBitmap(u16list, u16, ptr exec_ctx) - u8list GenLargeBitmap(u32list, u32, ptr exec_ctx) - u8list GenLargeBitmap(u64list, u64, ptr exec_ctx) - u8list GenLargeBitmap(i8list, i8, ptr exec_ctx) - u8list GenLargeBitmap(i16list, i16, ptr exec_ctx) - u8list GenLargeBitmap(i32list, i32, ptr exec_ctx) - u8list GenLargeBitmap(i64list, i64, ptr exec_ctx) - u8list GenLargeBitmap(f32list, f32, ptr exec_ctx) - u8list GenLargeBitmap(f64list, f64, ptr exec_ctx) + u8list GenLargeBitmap(u8list, u8) + u8list GenLargeBitmap(u16list, u16) + u8list GenLargeBitmap(u32list, u32) + u8list GenLargeBitmap(u64list, u64) + u8list GenLargeBitmap(i8list, i8) + u8list GenLargeBitmap(i16list, i16) + u8list GenLargeBitmap(i32list, i32) + u8list GenLargeBitmap(i64list, i64) + u8list GenLargeBitmap(f32list, f32) + u8list GenLargeBitmap(f64list, f64) Return a bitmap representing the results of greater-than comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLargeBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLargeBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLargeBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLargeBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLargeBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLargeBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLargeBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLargeBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLargeBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLargeBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLargeBitmap(u8list, u8list) + u8list GenLargeBitmap(u16list, u16list) + u8list GenLargeBitmap(u32list, u32list) + u8list GenLargeBitmap(u64list, u64list) + u8list GenLargeBitmap(i8list, i8list) + u8list GenLargeBitmap(i16list, i16list) + u8list GenLargeBitmap(i32list, i32list) + u8list GenLargeBitmap(i64list, i64list) + u8list GenLargeBitmap(f32list, f32list) + u8list GenLargeBitmap(f64list, f64list) ## GenLargeEqualBitmap Return a bitmap representation after performing a greater-than or equal comparison on all elements in the list. - u8list GenLargeEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenLargeEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenLargeEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenLargeEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenLargeEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenLargeEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenLargeEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenLargeEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenLargeEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenLargeEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenLargeEqualBitmap(u8list, u8) + u8list GenLargeEqualBitmap(u16list, u16) + u8list GenLargeEqualBitmap(u32list, u32) + u8list GenLargeEqualBitmap(u64list, u64) + u8list GenLargeEqualBitmap(i8list, i8) + u8list GenLargeEqualBitmap(i16list, i16) + u8list GenLargeEqualBitmap(i32list, i32) + u8list GenLargeEqualBitmap(i64list, i64) + u8list GenLargeEqualBitmap(f32list, f32) + u8list GenLargeEqualBitmap(f64list, f64) Return a bitmap representing the results of greater-than or equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLargeEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLargeEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLargeEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLargeEqualBitmap(u8list, u8list) + u8list GenLargeEqualBitmap(u16list, u16list) + u8list GenLargeEqualBitmap(u32list, u32list) + u8list GenLargeEqualBitmap(u64list, u64list) + u8list GenLargeEqualBitmap(i8list, i8list) + u8list GenLargeEqualBitmap(i16list, i16list) + u8list GenLargeEqualBitmap(i32list, i32list) + u8list GenLargeEqualBitmap(i64list, i64list) + u8list GenLargeEqualBitmap(f32list, f32list) + u8list GenLargeEqualBitmap(f64list, f64list) ## GenEqualBitmap Return a bitmap representation after performing a equal comparison on all elements in the list. - u8list GenEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenEqualBitmap(u8list, u8) + u8list GenEqualBitmap(u16list, u16) + u8list GenEqualBitmap(u32list, u32) + u8list GenEqualBitmap(u64list, u64) + u8list GenEqualBitmap(i8list, i8) + u8list GenEqualBitmap(i16list, i16) + u8list GenEqualBitmap(i32list, i32) + u8list GenEqualBitmap(i64list, i64) + u8list GenEqualBitmap(f32list, f32) + u8list GenEqualBitmap(f64list, f64) Return a bitmap representing the results of equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenEqualBitmap(u8list, u8list) + u8list GenEqualBitmap(u16list, u16list) + u8list GenEqualBitmap(u32list, u32list) + u8list GenEqualBitmap(u64list, u64list) + u8list GenEqualBitmap(i8list, i8list) + u8list GenEqualBitmap(i16list, i16list) + u8list GenEqualBitmap(i32list, i32list) + u8list GenEqualBitmap(i64list, i64list) + u8list GenEqualBitmap(f32list, f32list) + u8list GenEqualBitmap(f64list, f64list) ## GenLessBitmap Return a bitmap representation after performing a less-than comparison on all elements in the list. - u8list GenLessBitmap(u8list, u8, ptr exec_ctx) - u8list GenLessBitmap(u16list, u16, ptr exec_ctx) - u8list GenLessBitmap(u32list, u32, ptr exec_ctx) - u8list GenLessBitmap(u64list, u64, ptr exec_ctx) - u8list GenLessBitmap(i8list, i8, ptr exec_ctx) - u8list GenLessBitmap(i16list, i16, ptr exec_ctx) - u8list GenLessBitmap(i32list, i32, ptr exec_ctx) - u8list GenLessBitmap(i64list, i64, ptr exec_ctx) - u8list GenLessBitmap(f32list, f32, ptr exec_ctx) - u8list GenLessBitmap(f64list, f64, ptr exec_ctx) + u8list GenLessBitmap(u8list, u8) + u8list GenLessBitmap(u16list, u16) + u8list GenLessBitmap(u32list, u32) + u8list GenLessBitmap(u64list, u64) + u8list GenLessBitmap(i8list, i8) + u8list GenLessBitmap(i16list, i16) + u8list GenLessBitmap(i32list, i32) + u8list GenLessBitmap(i64list, i64) + u8list GenLessBitmap(f32list, f32) + u8list GenLessBitmap(f64list, f64) Return a bitmap representing the results of less-than comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLessBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLessBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLessBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLessBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLessBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLessBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLessBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLessBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLessBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLessBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLessBitmap(u8list, u8list) + u8list GenLessBitmap(u16list, u16list) + u8list GenLessBitmap(u32list, u32list) + u8list GenLessBitmap(u64list, u64list) + u8list GenLessBitmap(i8list, i8list) + u8list GenLessBitmap(i16list, i16list) + u8list GenLessBitmap(i32list, i32list) + u8list GenLessBitmap(i64list, i64list) + u8list GenLessBitmap(f32list, f32list) + u8list GenLessBitmap(f64list, f64list) ## GenLessEqualBitmap Return a bitmap representation after performing a less-than or equal comparison on all elements in the list. - u8list GenLessEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenLessEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenLessEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenLessEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenLessEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenLessEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenLessEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenLessEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenLessEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenLessEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenLessEqualBitmap(u8list, u8) + u8list GenLessEqualBitmap(u16list, u16) + u8list GenLessEqualBitmap(u32list, u32) + u8list GenLessEqualBitmap(u64list, u64) + u8list GenLessEqualBitmap(i8list, i8) + u8list GenLessEqualBitmap(i16list, i16) + u8list GenLessEqualBitmap(i32list, i32) + u8list GenLessEqualBitmap(i64list, i64) + u8list GenLessEqualBitmap(f32list, f32) + u8list GenLessEqualBitmap(f64list, f64) Return a bitmap representing the results of less-than or equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenLessEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenLessEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenLessEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenLessEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenLessEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenLessEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenLessEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenLessEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenLessEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenLessEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenLessEqualBitmap(u8list, u8list) + u8list GenLessEqualBitmap(u16list, u16list) + u8list GenLessEqualBitmap(u32list, u32list) + u8list GenLessEqualBitmap(u64list, u64list) + u8list GenLessEqualBitmap(i8list, i8list) + u8list GenLessEqualBitmap(i16list, i16list) + u8list GenLessEqualBitmap(i32list, i32list) + u8list GenLessEqualBitmap(i64list, i64list) + u8list GenLessEqualBitmap(f32list, f32list) + u8list GenLessEqualBitmap(f64list, f64list) ## GenNotEqualBitmap Return a bitmap representation after performing a not equal comparison on all elements in the list. - u8list GenNotEqualBitmap(u8list, u8, ptr exec_ctx) - u8list GenNotEqualBitmap(u16list, u16, ptr exec_ctx) - u8list GenNotEqualBitmap(u32list, u32, ptr exec_ctx) - u8list GenNotEqualBitmap(u64list, u64, ptr exec_ctx) - u8list GenNotEqualBitmap(i8list, i8, ptr exec_ctx) - u8list GenNotEqualBitmap(i16list, i16, ptr exec_ctx) - u8list GenNotEqualBitmap(i32list, i32, ptr exec_ctx) - u8list GenNotEqualBitmap(i64list, i64, ptr exec_ctx) - u8list GenNotEqualBitmap(f32list, f32, ptr exec_ctx) - u8list GenNotEqualBitmap(f64list, f64, ptr exec_ctx) + u8list GenNotEqualBitmap(u8list, u8) + u8list GenNotEqualBitmap(u16list, u16) + u8list GenNotEqualBitmap(u32list, u32) + u8list GenNotEqualBitmap(u64list, u64) + u8list GenNotEqualBitmap(i8list, i8) + u8list GenNotEqualBitmap(i16list, i16) + u8list GenNotEqualBitmap(i32list, i32) + u8list GenNotEqualBitmap(i64list, i64) + u8list GenNotEqualBitmap(f32list, f32) + u8list GenNotEqualBitmap(f64list, f64) Return a bitmap representing the results of not equal comparisons for each element in the two lists. Both lists must have equal length. - u8list GenNotEqualBitmap(u8list, u8list, ptr exec_ctx) - u8list GenNotEqualBitmap(u16list, u16list, ptr exec_ctx) - u8list GenNotEqualBitmap(u32list, u32list, ptr exec_ctx) - u8list GenNotEqualBitmap(u64list, u64list, ptr exec_ctx) - u8list GenNotEqualBitmap(i8list, i8list, ptr exec_ctx) - u8list GenNotEqualBitmap(i16list, i16list, ptr exec_ctx) - u8list GenNotEqualBitmap(i32list, i32list, ptr exec_ctx) - u8list GenNotEqualBitmap(i64list, i64list, ptr exec_ctx) - u8list GenNotEqualBitmap(f32list, f32list, ptr exec_ctx) - u8list GenNotEqualBitmap(f64list, f64list, ptr exec_ctx) + u8list GenNotEqualBitmap(u8list, u8list) + u8list GenNotEqualBitmap(u16list, u16list) + u8list GenNotEqualBitmap(u32list, u32list) + u8list GenNotEqualBitmap(u64list, u64list) + u8list GenNotEqualBitmap(i8list, i8list) + u8list GenNotEqualBitmap(i16list, i16list) + u8list GenNotEqualBitmap(i32list, i32list) + u8list GenNotEqualBitmap(i64list, i64list) + u8list GenNotEqualBitmap(f32list, f32list) + u8list GenNotEqualBitmap(f64list, f64list) ## FilterByBitmap Return a new list by filtering out the corresponding elements based on the bitmap. - u8list FilterByBitmap(u8list src, u8list bitmap, ptr exec_ctx) - u16list FilterByBitmap(u16list src, u8list bitmap, ptr exec_ctx) - u32list FilterByBitmap(u32list src, u8list bitmap, ptr exec_ctx) - u64list FilterByBitmap(u64list src, u8list bitmap, ptr exec_ctx) - i8list FilterByBitmap(i8list src, u8list bitmap, ptr exec_ctx) - i16list FilterByBitmap(i16list src, u8list bitmap, ptr exec_ctx) - i32list FilterByBitmap(i32list src, u8list bitmap, ptr exec_ctx) - i64list FilterByBitmap(i64list src, u8list bitmap, ptr exec_ctx) - f32list FilterByBitmap(f32list src, u8list bitmap, ptr exec_ctx) - f64list FilterByBitmap(f64list src, u8list bitmap, ptr exec_ctx) + u8list FilterByBitmap(u8list src, u8list bitmap) + u16list FilterByBitmap(u16list src, u8list bitmap) + u32list FilterByBitmap(u32list src, u8list bitmap) + u64list FilterByBitmap(u64list src, u8list bitmap) + i8list FilterByBitmap(i8list src, u8list bitmap) + i16list FilterByBitmap(i16list src, u8list bitmap) + i32list FilterByBitmap(i32list src, u8list bitmap) + i64list FilterByBitmap(i64list src, u8list bitmap) + f32list FilterByBitmap(f32list src, u8list bitmap) + f64list FilterByBitmap(f64list src, u8list bitmap) ## CountBits Count the number of 1s in the bitmap. @@ -1123,122 +1123,122 @@ Count the number of 1s in the bitmap. ## IfLarge Traverse the list to find all values that meet the condition of being greater than the specified value, modify them to the target value, and return a new list. - u8list IfLarge(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLarge(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLarge(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLarge(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLarge(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLarge(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLarge(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLarge(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLarge(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLarge(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLarge(u8list src, u8 cmp_value, u8 target_value) + u16list IfLarge(u16list src, u16 cmp_value, u16 target_value) + u32list IfLarge(u32list src, u32 cmp_value, u32 target_value) + u64list IfLarge(u64list src, u64 cmp_value, u64 target_value) + i8list IfLarge(i8list src, i8 cmp_value, i8 target_value) + i16list IfLarge(i16list src, i16 cmp_value, i16 target_value) + i32list IfLarge(i32list src, i32 cmp_value, i32 target_value) + i64list IfLarge(i64list src, i64 cmp_value, i64 target_value) + f32list IfLarge(f32list src, f32 cmp_value, f32 target_value) + f64list IfLarge(f64list src, f64 cmp_value, f64 target_value) ## IfLargeEqual Traverse the list to find all values that meet the condition of being greater than or equal to the specified value, modify them to the target value, and return a new list. - u8list IfLargeEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLargeEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLargeEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLargeEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLargeEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLargeEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLargeEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLargeEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLargeEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLargeEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLargeEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfLargeEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfLargeEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfLargeEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfLargeEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfLargeEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfLargeEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfLargeEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfLargeEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfLargeEqual(f64list src, f64 cmp_value, f64 target_value) ## IfEqual Traverse the list to find all values that meet the condition of being equal to the specified value, modify them to the target value, and return a new list. - u8list IfEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfEqual(f64list src, f64 cmp_value, f64 target_value) ## IfLess Traverse the list to find all values that meet the condition of being less than the specified value, modify them to the target value, and return a new list. - u8list IfLess(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLess(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLess(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLess(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLess(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLess(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLess(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLess(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLess(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLess(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLess(u8list src, u8 cmp_value, u8 target_value) + u16list IfLess(u16list src, u16 cmp_value, u16 target_value) + u32list IfLess(u32list src, u32 cmp_value, u32 target_value) + u64list IfLess(u64list src, u64 cmp_value, u64 target_value) + i8list IfLess(i8list src, i8 cmp_value, i8 target_value) + i16list IfLess(i16list src, i16 cmp_value, i16 target_value) + i32list IfLess(i32list src, i32 cmp_value, i32 target_value) + i64list IfLess(i64list src, i64 cmp_value, i64 target_value) + f32list IfLess(f32list src, f32 cmp_value, f32 target_value) + f64list IfLess(f64list src, f64 cmp_value, f64 target_value) ## IfLessEqual Traverse the list to find all values that meet the condition of being less than or equal to the specified value, modify them to the target value, and return a new list. - u8list IfLessEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfLessEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfLessEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfLessEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfLessEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfLessEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfLessEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfLessEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfLessEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfLessEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfLessEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfLessEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfLessEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfLessEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfLessEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfLessEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfLessEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfLessEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfLessEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfLessEqual(f64list src, f64 cmp_value, f64 target_value) ## IfNotEqual Traverse the list to find all values that meet the condition of being not equal to the specified value, modify them to the target value, and return a new list. - u8list IfNotEqual(u8list src, u8 cmp_value, u8 target_value, ptr exec_ctx) - u16list IfNotEqual(u16list src, u16 cmp_value, u16 target_value, ptr exec_ctx) - u32list IfNotEqual(u32list src, u32 cmp_value, u32 target_value, ptr exec_ctx) - u64list IfNotEqual(u64list src, u64 cmp_value, u64 target_value, ptr exec_ctx) - i8list IfNotEqual(i8list src, i8 cmp_value, i8 target_value, ptr exec_ctx) - i16list IfNotEqual(i16list src, i16 cmp_value, i16 target_value, ptr exec_ctx) - i32list IfNotEqual(i32list src, i32 cmp_value, i32 target_value, ptr exec_ctx) - i64list IfNotEqual(i64list src, i64 cmp_value, i64 target_value, ptr exec_ctx) - f32list IfNotEqual(f32list src, f32 cmp_value, f32 target_value, ptr exec_ctx) - f64list IfNotEqual(f64list src, f64 cmp_value, f64 target_value, ptr exec_ctx) + u8list IfNotEqual(u8list src, u8 cmp_value, u8 target_value) + u16list IfNotEqual(u16list src, u16 cmp_value, u16 target_value) + u32list IfNotEqual(u32list src, u32 cmp_value, u32 target_value) + u64list IfNotEqual(u64list src, u64 cmp_value, u64 target_value) + i8list IfNotEqual(i8list src, i8 cmp_value, i8 target_value) + i16list IfNotEqual(i16list src, i16 cmp_value, i16 target_value) + i32list IfNotEqual(i32list src, i32 cmp_value, i32 target_value) + i64list IfNotEqual(i64list src, i64 cmp_value, i64 target_value) + f32list IfNotEqual(f32list src, f32 cmp_value, f32 target_value) + f64list IfNotEqual(f64list src, f64 cmp_value, f64 target_value) ## IfByBitmap Return a new list based on the values from the bitmap. - u8list IfByBitmap(u8list bitmap, u8list lhs, u8 rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16list lhs, u16 rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32list lhs, u32 rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64list lhs, u64 rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8list lhs, i8 rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16list lhs, i16 rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32list lhs, i32 rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64list lhs, i64 rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32list lhs, f32 rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64list lhs, f64 rhs, ptr exec_ctx) - - u8list IfByBitmap(u8list bitmap, u8 lhs, u8list rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16 lhs, u16list rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32 lhs, u32list rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64 lhs, u64list rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8 lhs, i8list rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16 lhs, i16list rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32 lhs, i32list rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64 lhs, i64list rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32 lhs, f32list rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64 lhs, f64list rhs, ptr exec_ctx) - - u8list IfByBitmap(u8list bitmap, u8list lhs, u8list rhs, ptr exec_ctx) - u16list IfByBitmap(u8list bitmap, u16list lhs, u16list rhs, ptr exec_ctx) - u32list IfByBitmap(u8list bitmap, u32list lhs, u32list rhs, ptr exec_ctx) - u64list IfByBitmap(u8list bitmap, u64list lhs, u64list rhs, ptr exec_ctx) - i8list IfByBitmap(u8list bitmap, i8list lhs, i8list rhs, ptr exec_ctx) - i16list IfByBitmap(u8list bitmap, i16list lhs, i16list rhs, ptr exec_ctx) - i32list IfByBitmap(u8list bitmap, i32list lhs, i32list rhs, ptr exec_ctx) - i64list IfByBitmap(u8list bitmap, i64list lhs, i64list rhs, ptr exec_ctx) - f32list IfByBitmap(u8list bitmap, f32list lhs, f32list rhs, ptr exec_ctx) - f64list IfByBitmap(u8list bitmap, f64list lhs, f64list rhs, ptr exec_ctx) + u8list IfByBitmap(u8list bitmap, u8list lhs, u8 rhs) + u16list IfByBitmap(u8list bitmap, u16list lhs, u16 rhs) + u32list IfByBitmap(u8list bitmap, u32list lhs, u32 rhs) + u64list IfByBitmap(u8list bitmap, u64list lhs, u64 rhs) + i8list IfByBitmap(u8list bitmap, i8list lhs, i8 rhs) + i16list IfByBitmap(u8list bitmap, i16list lhs, i16 rhs) + i32list IfByBitmap(u8list bitmap, i32list lhs, i32 rhs) + i64list IfByBitmap(u8list bitmap, i64list lhs, i64 rhs) + f32list IfByBitmap(u8list bitmap, f32list lhs, f32 rhs) + f64list IfByBitmap(u8list bitmap, f64list lhs, f64 rhs) + + u8list IfByBitmap(u8list bitmap, u8 lhs, u8list rhs) + u16list IfByBitmap(u8list bitmap, u16 lhs, u16list rhs) + u32list IfByBitmap(u8list bitmap, u32 lhs, u32list rhs) + u64list IfByBitmap(u8list bitmap, u64 lhs, u64list rhs) + i8list IfByBitmap(u8list bitmap, i8 lhs, i8list rhs) + i16list IfByBitmap(u8list bitmap, i16 lhs, i16list rhs) + i32list IfByBitmap(u8list bitmap, i32 lhs, i32list rhs) + i64list IfByBitmap(u8list bitmap, i64 lhs, i64list rhs) + f32list IfByBitmap(u8list bitmap, f32 lhs, f32list rhs) + f64list IfByBitmap(u8list bitmap, f64 lhs, f64list rhs) + + u8list IfByBitmap(u8list bitmap, u8list lhs, u8list rhs) + u16list IfByBitmap(u8list bitmap, u16list lhs, u16list rhs) + u32list IfByBitmap(u8list bitmap, u32list lhs, u32list rhs) + u64list IfByBitmap(u8list bitmap, u64list lhs, u64list rhs) + i8list IfByBitmap(u8list bitmap, i8list lhs, i8list rhs) + i16list IfByBitmap(u8list bitmap, i16list lhs, i16list rhs) + i32list IfByBitmap(u8list bitmap, i32list lhs, i32list rhs) + i64list IfByBitmap(u8list bitmap, i64list lhs, i64list rhs) + f32list IfByBitmap(u8list bitmap, f32list lhs, f32list rhs) + f64list IfByBitmap(u8list bitmap, f64list lhs, f64list rhs) ## MurmurHash3X8632 MurmurHash3_x86_32 algorithm @@ -1259,145 +1259,145 @@ List Type Conversion Functions. Cast a list from one element type to another. Numeric/String list to numeric list conversion: - u8list CastU8List(i8list src, ptr exec_ctx) - u8list CastU8List(u16list src, ptr exec_ctx) - u8list CastU8List(i16list src, ptr exec_ctx) - u8list CastU8List(u32list src, ptr exec_ctx) - u8list CastU8List(i32list src, ptr exec_ctx) - u8list CastU8List(u64list src, ptr exec_ctx) - u8list CastU8List(i64list src, ptr exec_ctx) - u8list CastU8List(f32list src, ptr exec_ctx) - u8list CastU8List(f64list src, ptr exec_ctx) - u8list CastU8List(stringlist src, ptr exec_ctx) - - i8list CastI8List(u8list src, ptr exec_ctx) - i8list CastI8List(u16list src, ptr exec_ctx) - i8list CastI8List(i16list src, ptr exec_ctx) - i8list CastI8List(u32list src, ptr exec_ctx) - i8list CastI8List(i32list src, ptr exec_ctx) - i8list CastI8List(u64list src, ptr exec_ctx) - i8list CastI8List(i64list src, ptr exec_ctx) - i8list CastI8List(f32list src, ptr exec_ctx) - i8list CastI8List(f64list src, ptr exec_ctx) - i8list CastI8List(stringlist src, ptr exec_ctx) - - u16list CastU16List(u8list src, ptr exec_ctx) - u16list CastU16List(i8list src, ptr exec_ctx) - u16list CastU16List(i16list src, ptr exec_ctx) - u16list CastU16List(u32list src, ptr exec_ctx) - u16list CastU16List(i32list src, ptr exec_ctx) - u16list CastU16List(u64list src, ptr exec_ctx) - u16list CastU16List(i64list src, ptr exec_ctx) - u16list CastU16List(f32list src, ptr exec_ctx) - u16list CastU16List(f64list src, ptr exec_ctx) - u16list CastU16List(stringlist src, ptr exec_ctx) - - i16list CastI16List(u8list src, ptr exec_ctx) - i16list CastI16List(i8list src, ptr exec_ctx) - i16list CastI16List(u16list src, ptr exec_ctx) - i16list CastI16List(u32list src, ptr exec_ctx) - i16list CastI16List(i32list src, ptr exec_ctx) - i16list CastI16List(u64list src, ptr exec_ctx) - i16list CastI16List(i64list src, ptr exec_ctx) - i16list CastI16List(f32list src, ptr exec_ctx) - i16list CastI16List(f64list src, ptr exec_ctx) - i16list CastI16List(stringlist src, ptr exec_ctx) - - u32list CastU32List(u8list src, ptr exec_ctx) - u32list CastU32List(i8list src, ptr exec_ctx) - u32list CastU32List(u16list src, ptr exec_ctx) - u32list CastU32List(i16list src, ptr exec_ctx) - u32list CastU32List(i32list src, ptr exec_ctx) - u32list CastU32List(u64list src, ptr exec_ctx) - u32list CastU32List(i64list src, ptr exec_ctx) - u32list CastU32List(f32list src, ptr exec_ctx) - u32list CastU32List(f64list src, ptr exec_ctx) - u32list CastU32List(stringlist src, ptr exec_ctx) - - i32list CastI32List(u8list src, ptr exec_ctx) - i32list CastI32List(i8list src, ptr exec_ctx) - i32list CastI32List(u16list src, ptr exec_ctx) - i32list CastI32List(i16list src, ptr exec_ctx) - i32list CastI32List(u32list src, ptr exec_ctx) - i32list CastI32List(u64list src, ptr exec_ctx) - i32list CastI32List(i64list src, ptr exec_ctx) - i32list CastI32List(f32list src, ptr exec_ctx) - i32list CastI32List(f64list src, ptr exec_ctx) - i32list CastI32List(stringlist src, ptr exec_ctx) - - u64list CastU64List(u8list src, ptr exec_ctx) - u64list CastU64List(i8list src, ptr exec_ctx) - u64list CastU64List(u16list src, ptr exec_ctx) - u64list CastU64List(i16list src, ptr exec_ctx) - u64list CastU64List(u32list src, ptr exec_ctx) - u64list CastU64List(i32list src, ptr exec_ctx) - u64list CastU64List(i64list src, ptr exec_ctx) - u64list CastU64List(f32list src, ptr exec_ctx) - u64list CastU64List(f64list src, ptr exec_ctx) - u64list CastU64List(stringlist src, ptr exec_ctx) - - i64list CastI64List(u8list src, ptr exec_ctx) - i64list CastI64List(i8list src, ptr exec_ctx) - i64list CastI64List(u16list src, ptr exec_ctx) - i64list CastI64List(i16list src, ptr exec_ctx) - i64list CastI64List(u32list src, ptr exec_ctx) - i64list CastI64List(i32list src, ptr exec_ctx) - i64list CastI64List(u64list src, ptr exec_ctx) - i64list CastI64List(f32list src, ptr exec_ctx) - i64list CastI64List(f64list src, ptr exec_ctx) - i64list CastI64List(stringlist src, ptr exec_ctx) - - f32list CastF32List(u8list src, ptr exec_ctx) - f32list CastF32List(i8list src, ptr exec_ctx) - f32list CastF32List(u16list src, ptr exec_ctx) - f32list CastF32List(i16list src, ptr exec_ctx) - f32list CastF32List(u32list src, ptr exec_ctx) - f32list CastF32List(i32list src, ptr exec_ctx) - f32list CastF32List(u64list src, ptr exec_ctx) - f32list CastF32List(i64list src, ptr exec_ctx) - f32list CastF32List(f64list src, ptr exec_ctx) - - f64list CastF64List(u8list src, ptr exec_ctx) - f64list CastF64List(i8list src, ptr exec_ctx) - f64list CastF64List(u16list src, ptr exec_ctx) - f64list CastF64List(i16list src, ptr exec_ctx) - f64list CastF64List(u32list src, ptr exec_ctx) - f64list CastF64List(i32list src, ptr exec_ctx) - f64list CastF64List(u64list src, ptr exec_ctx) - f64list CastF64List(i64list src, ptr exec_ctx) - f64list CastF64List(f32list src, ptr exec_ctx) + u8list CastU8List(i8list src) + u8list CastU8List(u16list src) + u8list CastU8List(i16list src) + u8list CastU8List(u32list src) + u8list CastU8List(i32list src) + u8list CastU8List(u64list src) + u8list CastU8List(i64list src) + u8list CastU8List(f32list src) + u8list CastU8List(f64list src) + u8list CastU8List(stringlist src) + + i8list CastI8List(u8list src) + i8list CastI8List(u16list src) + i8list CastI8List(i16list src) + i8list CastI8List(u32list src) + i8list CastI8List(i32list src) + i8list CastI8List(u64list src) + i8list CastI8List(i64list src) + i8list CastI8List(f32list src) + i8list CastI8List(f64list src) + i8list CastI8List(stringlist src) + + u16list CastU16List(u8list src) + u16list CastU16List(i8list src) + u16list CastU16List(i16list src) + u16list CastU16List(u32list src) + u16list CastU16List(i32list src) + u16list CastU16List(u64list src) + u16list CastU16List(i64list src) + u16list CastU16List(f32list src) + u16list CastU16List(f64list src) + u16list CastU16List(stringlist src) + + i16list CastI16List(u8list src) + i16list CastI16List(i8list src) + i16list CastI16List(u16list src) + i16list CastI16List(u32list src) + i16list CastI16List(i32list src) + i16list CastI16List(u64list src) + i16list CastI16List(i64list src) + i16list CastI16List(f32list src) + i16list CastI16List(f64list src) + i16list CastI16List(stringlist src) + + u32list CastU32List(u8list src) + u32list CastU32List(i8list src) + u32list CastU32List(u16list src) + u32list CastU32List(i16list src) + u32list CastU32List(i32list src) + u32list CastU32List(u64list src) + u32list CastU32List(i64list src) + u32list CastU32List(f32list src) + u32list CastU32List(f64list src) + u32list CastU32List(stringlist src) + + i32list CastI32List(u8list src) + i32list CastI32List(i8list src) + i32list CastI32List(u16list src) + i32list CastI32List(i16list src) + i32list CastI32List(u32list src) + i32list CastI32List(u64list src) + i32list CastI32List(i64list src) + i32list CastI32List(f32list src) + i32list CastI32List(f64list src) + i32list CastI32List(stringlist src) + + u64list CastU64List(u8list src) + u64list CastU64List(i8list src) + u64list CastU64List(u16list src) + u64list CastU64List(i16list src) + u64list CastU64List(u32list src) + u64list CastU64List(i32list src) + u64list CastU64List(i64list src) + u64list CastU64List(f32list src) + u64list CastU64List(f64list src) + u64list CastU64List(stringlist src) + + i64list CastI64List(u8list src) + i64list CastI64List(i8list src) + i64list CastI64List(u16list src) + i64list CastI64List(i16list src) + i64list CastI64List(u32list src) + i64list CastI64List(i32list src) + i64list CastI64List(u64list src) + i64list CastI64List(f32list src) + i64list CastI64List(f64list src) + i64list CastI64List(stringlist src) + + f32list CastF32List(u8list src) + f32list CastF32List(i8list src) + f32list CastF32List(u16list src) + f32list CastF32List(i16list src) + f32list CastF32List(u32list src) + f32list CastF32List(i32list src) + f32list CastF32List(u64list src) + f32list CastF32List(i64list src) + f32list CastF32List(f64list src) + + f64list CastF64List(u8list src) + f64list CastF64List(i8list src) + f64list CastF64List(u16list src) + f64list CastF64List(i16list src) + f64list CastF64List(u32list src) + f64list CastF64List(i32list src) + f64list CastF64List(u64list src) + f64list CastF64List(i64list src) + f64list CastF64List(f32list src) Note: CastF32List and CastF64List do not support stringlist input. String to integer list conversion uses std::from_chars internally. String to floating-point list conversion is not supported in C++17. Numeric list to string list conversion: - stringlist CastStringList(u8list src, ptr exec_ctx) - stringlist CastStringList(i8list src, ptr exec_ctx) - stringlist CastStringList(u16list src, ptr exec_ctx) - stringlist CastStringList(i16list src, ptr exec_ctx) - stringlist CastStringList(u32list src, ptr exec_ctx) - stringlist CastStringList(i32list src, ptr exec_ctx) - stringlist CastStringList(u64list src, ptr exec_ctx) - stringlist CastStringList(i64list src, ptr exec_ctx) - stringlist CastStringList(f32list src, ptr exec_ctx) - stringlist CastStringList(f64list src, ptr exec_ctx) + stringlist CastStringList(u8list src) + stringlist CastStringList(i8list src) + stringlist CastStringList(u16list src) + stringlist CastStringList(i16list src) + stringlist CastStringList(u32list src) + stringlist CastStringList(i32list src) + stringlist CastStringList(u64list src) + stringlist CastStringList(i64list src) + stringlist CastStringList(f32list src) + stringlist CastStringList(f64list src) ## ListLookupIndex Given two lists `a` and `b` of the same element type, for each element in `a` return the position of its first occurrence in `b`. When an element of `a` is not found in `b`, the result entry is set to `u32max` (`std::numeric_limits::max()`) as a miss sentinel. Internally a hash table over `b` is built, so the per-element lookup is amortised O(1). The output length always equals `a.len`. - u32list ListLookupIndex(u8list a, u8list b, ptr exec_ctx) - u32list ListLookupIndex(i8list a, i8list b, ptr exec_ctx) - u32list ListLookupIndex(u16list a, u16list b, ptr exec_ctx) - u32list ListLookupIndex(i16list a, i16list b, ptr exec_ctx) - u32list ListLookupIndex(u32list a, u32list b, ptr exec_ctx) - u32list ListLookupIndex(i32list a, i32list b, ptr exec_ctx) - u32list ListLookupIndex(u64list a, u64list b, ptr exec_ctx) - u32list ListLookupIndex(i64list a, i64list b, ptr exec_ctx) - u32list ListLookupIndex(f32list a, f32list b, ptr exec_ctx) - u32list ListLookupIndex(f64list a, f64list b, ptr exec_ctx) - u32list ListLookupIndex(stringlist a, stringlist b, ptr exec_ctx) + u32list ListLookupIndex(u8list a, u8list b) + u32list ListLookupIndex(i8list a, i8list b) + u32list ListLookupIndex(u16list a, u16list b) + u32list ListLookupIndex(i16list a, i16list b) + u32list ListLookupIndex(u32list a, u32list b) + u32list ListLookupIndex(i32list a, i32list b) + u32list ListLookupIndex(u64list a, u64list b) + u32list ListLookupIndex(i64list a, i64list b) + u32list ListLookupIndex(f32list a, f32list b) + u32list ListLookupIndex(f64list a, f64list b) + u32list ListLookupIndex(stringlist a, stringlist b) ## Find Return the index of the first occurrence of `value` in the list. Returns `u32max` (`std::numeric_limits::max()`) when the value is not found. This is the scalar counterpart of `ListLookupIndex` and composes naturally with `GetAt`: `GetAt(values, Find(keys, k))` performs a scalar join (miss falls through to `GetAt`'s out-of-bounds default of zero/empty). @@ -1442,31 +1442,31 @@ Takes a `u32list` produced by `ListLookupIndex` and returns the positions in `a` Output length equals the number of hits; preserves the original order. - u32list ListCompactPositions(u32list raw, ptr exec_ctx) + u32list ListCompactPositions(u32list raw) ## ListCompactIndex Takes a `u32list` produced by `ListLookupIndex` and returns the looked-up b-side indices themselves, skipping miss entries. Useful for directly gathering a b-side column aligned to the hit subset of a. Output length equals the number of hits; preserves the original order. - u32list ListCompactIndex(u32list raw, ptr exec_ctx) + u32list ListCompactIndex(u32list raw) ## ListGather Element-wise gather from a `values` list using a `u32list` of positions. For each `k`, if `idx[k] < values.len` the output is `values[idx[k]]`, otherwise it is the supplied `default_value`. This is the typical "realign a b-side column to the a-side shape" kernel of a join. The output length always equals `idx.len`. - u8list ListGather(u8list values, u32list idx, u8 default_value, ptr exec_ctx) - i8list ListGather(i8list values, u32list idx, i8 default_value, ptr exec_ctx) - u16list ListGather(u16list values, u32list idx, u16 default_value, ptr exec_ctx) - i16list ListGather(i16list values, u32list idx, i16 default_value, ptr exec_ctx) - u32list ListGather(u32list values, u32list idx, u32 default_value, ptr exec_ctx) - i32list ListGather(i32list values, u32list idx, i32 default_value, ptr exec_ctx) - u64list ListGather(u64list values, u32list idx, u64 default_value, ptr exec_ctx) - i64list ListGather(i64list values, u32list idx, i64 default_value, ptr exec_ctx) - f32list ListGather(f32list values, u32list idx, f32 default_value, ptr exec_ctx) - f64list ListGather(f64list values, u32list idx, f64 default_value, ptr exec_ctx) - stringlist ListGather(stringlist values, u32list idx, string default_value, ptr exec_ctx) + u8list ListGather(u8list values, u32list idx, u8 default_value) + i8list ListGather(i8list values, u32list idx, i8 default_value) + u16list ListGather(u16list values, u32list idx, u16 default_value) + i16list ListGather(i16list values, u32list idx, i16 default_value) + u32list ListGather(u32list values, u32list idx, u32 default_value) + i32list ListGather(i32list values, u32list idx, i32 default_value) + u64list ListGather(u64list values, u32list idx, u64 default_value) + i64list ListGather(i64list values, u32list idx, i64 default_value) + f32list ListGather(f32list values, u32list idx, f32 default_value) + f64list ListGather(f64list values, u32list idx, f64 default_value) + stringlist ListGather(stringlist values, u32list idx, string default_value) ## Bucketize Classify each element of `values` into a half-open bin defined by an @@ -1492,13 +1492,13 @@ i.e. left-closed / right-open. Result has the same length as `values`. Implementation is `std::lower_bound`, O(log n) per value. - u32list Bucketize(u8list values, u8list boundaries, ptr exec_ctx) - u32list Bucketize(i8list values, i8list boundaries, ptr exec_ctx) - u32list Bucketize(u16list values, u16list boundaries, ptr exec_ctx) - u32list Bucketize(i16list values, i16list boundaries, ptr exec_ctx) - u32list Bucketize(u32list values, u32list boundaries, ptr exec_ctx) - u32list Bucketize(i32list values, i32list boundaries, ptr exec_ctx) - u32list Bucketize(u64list values, u64list boundaries, ptr exec_ctx) - u32list Bucketize(i64list values, i64list boundaries, ptr exec_ctx) - u32list Bucketize(f32list values, f32list boundaries, ptr exec_ctx) - u32list Bucketize(f64list values, f64list boundaries, ptr exec_ctx) + u32list Bucketize(u8list values, u8list boundaries) + u32list Bucketize(i8list values, i8list boundaries) + u32list Bucketize(u16list values, u16list boundaries) + u32list Bucketize(i16list values, i16list boundaries) + u32list Bucketize(u32list values, u32list boundaries) + u32list Bucketize(i32list values, i32list boundaries) + u32list Bucketize(u64list values, u64list boundaries) + u32list Bucketize(i64list values, i64list boundaries) + u32list Bucketize(f32list values, f32list boundaries) + u32list Bucketize(f64list values, f64list boundaries) diff --git a/src/exec_engine.cc b/src/exec_engine.cc index 0a918b9..b15c9eb 100644 --- a/src/exec_engine.cc +++ b/src/exec_engine.cc @@ -2,7 +2,7 @@ * @Author: victorika * @Date: 2025-01-15 10:59:33 * @Last Modified by: victorika - * @Last Modified time: 2026-05-09 14:42:00 + * @Last Modified time: 2026-05-11 17:07:36 */ #include "exec_engine.h"