merge bitcoin#28065: Flatten all FUZZ_TARGET macros into one

excludes:
- changes to `script_assets_test_minimizer.cpp` (we don't support
  taproot)

src/test/fuzz/addrman.cpp

@@ -45,7 +45,7 @@ void initialize_addrman()
     return NetGroupManager(asmap);
 }
 
-FUZZ_TARGET_INIT(data_stream_addr_man, initialize_addrman)
+FUZZ_TARGET(data_stream_addr_man, .init = initialize_addrman)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     CDataStream data_stream = ConsumeDataStream(fuzzed_data_provider);
@@ -232,7 +232,7 @@ class AddrManDeterministic : public AddrMan
     }
 };
 
-FUZZ_TARGET_INIT(addrman, initialize_addrman)
+FUZZ_TARGET(addrman, .init = initialize_addrman)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     SetMockTime(ConsumeTime(fuzzed_data_provider));
@@ -313,7 +313,7 @@ FUZZ_TARGET_INIT(addrman, initialize_addrman)
 }
 
 // Check that serialize followed by unserialize produces the same addrman.
-FUZZ_TARGET_INIT(addrman_serdeser, initialize_addrman)
+FUZZ_TARGET(addrman_serdeser, .init = initialize_addrman)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     SetMockTime(ConsumeTime(fuzzed_data_provider));

src/test/fuzz/banman.cpp

@@ -40,7 +40,7 @@ static bool operator==(const CBanEntry& lhs, const CBanEntry& rhs)
            lhs.nBanUntil == rhs.nBanUntil;
 }
 
-FUZZ_TARGET_INIT(banman, initialize_banman)
+FUZZ_TARGET(banman, .init = initialize_banman)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     SetMockTime(ConsumeTime(fuzzed_data_provider));

src/test/fuzz/bip324.cpp

@@ -19,7 +19,7 @@ void initialize_bip324()
     SelectParams(CBaseChainParams::MAIN);
 }
 
-FUZZ_TARGET_INIT(bip324_cipher_roundtrip, initialize_bip324)
+FUZZ_TARGET(bip324_cipher_roundtrip, .init = initialize_bip324)
 {
     // Test that BIP324Cipher's encryption and decryption agree.
 

src/test/fuzz/block.cpp

@@ -22,7 +22,7 @@ void initialize_block()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(block, initialize_block)
+FUZZ_TARGET(block, .init = initialize_block)
 {
     CDataStream ds(buffer, SER_NETWORK, INIT_PROTO_VERSION);
     CBlock block;

src/test/fuzz/coins_view.cpp

@@ -44,7 +44,7 @@ void initialize_coins_view()
     g_setup = testing_setup.get();
 }
 
-FUZZ_TARGET_INIT(coins_view, initialize_coins_view)
+FUZZ_TARGET(coins_view, .init = initialize_coins_view)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     CCoinsView backend_coins_view;

src/test/fuzz/connman.cpp

@@ -29,7 +29,7 @@ void initialize_connman()
     g_setup = testing_setup.get();
 }
 
-FUZZ_TARGET_INIT(connman, initialize_connman)
+FUZZ_TARGET(connman, .init = initialize_connman)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     SetMockTime(ConsumeTime(fuzzed_data_provider));

src/test/fuzz/descriptor_parse.cpp

@@ -15,7 +15,7 @@ void initialize_descriptor_parse()
     SelectParams(CBaseChainParams::MAIN);
 }
 
-FUZZ_TARGET_INIT(descriptor_parse, initialize_descriptor_parse)
+FUZZ_TARGET(descriptor_parse, .init = initialize_descriptor_parse)
 {
     const std::string descriptor(buffer.begin(), buffer.end());
     FlatSigningProvider signing_provider;

src/test/fuzz/deserialize.cpp

@@ -46,7 +46,7 @@ void initialize_deserialize()
 }
 
 #define FUZZ_TARGET_DESERIALIZE(name, code)                \
-    FUZZ_TARGET_INIT(name, initialize_deserialize)         \
+    FUZZ_TARGET(name, .init = initialize_deserialize)         \
     {                                                      \
         try {                                              \
             code                                           \

src/test/fuzz/fuzz.cpp

@@ -56,20 +56,25 @@ const std::function<std::vector<const char*>()> G_TEST_COMMAND_LINE_ARGUMENTS =
     return g_args;
 };
 
-std::map<std::string_view, std::tuple<TypeTestOneInput, TypeInitialize, TypeHidden>>& FuzzTargets()
+struct FuzzTarget {
+    const TypeTestOneInput test_one_input;
+    const FuzzTargetOptions opts;
+};
+
+auto& FuzzTargets()
 {
-    static std::map<std::string_view, std::tuple<TypeTestOneInput, TypeInitialize, TypeHidden>> g_fuzz_targets;
+    static std::map<std::string_view, FuzzTarget> g_fuzz_targets;
     return g_fuzz_targets;
 }
 
-void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, TypeInitialize init, TypeHidden hidden)
+void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, FuzzTargetOptions opts)
 {
-    const auto it_ins = FuzzTargets().try_emplace(name, std::move(target), std::move(init), hidden);
+    const auto it_ins{FuzzTargets().try_emplace(name, FuzzTarget /* temporary can be dropped in C++20 */ {std::move(target), std::move(opts)})};
     Assert(it_ins.second);
 }
 
 static std::string_view g_fuzz_target;
-static TypeTestOneInput* g_test_one_input{nullptr};
+static const TypeTestOneInput* g_test_one_input{nullptr};
 
 void initialize()
 {
@@ -86,22 +91,22 @@ void initialize()
 
     bool should_exit{false};
     if (std::getenv("PRINT_ALL_FUZZ_TARGETS_AND_ABORT")) {
-        for (const auto& t : FuzzTargets()) {
-            if (std::get<2>(t.second)) continue;
-            std::cout << t.first << std::endl;
+        for (const auto& [name, t] : FuzzTargets()) {
+            if (t.opts.hidden) continue;
+            std::cout << name << std::endl;
         }
         should_exit = true;
     }
     if (const char* out_path = std::getenv("WRITE_ALL_FUZZ_TARGETS_AND_ABORT")) {
         std::cout << "Writing all fuzz target names to '" << out_path << "'." << std::endl;
         std::ofstream out_stream{out_path, std::ios::binary};
-        for (const auto& t : FuzzTargets()) {
-            if (std::get<2>(t.second)) continue;
-            out_stream << t.first << std::endl;
+        for (const auto& [name, t] : FuzzTargets()) {
+            if (t.opts.hidden) continue;
+            out_stream << name << std::endl;
         }
-        should_exit= true;
+        should_exit = true;
     }
-    if (should_exit){
+    if (should_exit) {
         std::exit(EXIT_SUCCESS);
     }
     if (const auto* env_fuzz{std::getenv("FUZZ")}) {
@@ -119,8 +124,8 @@ void initialize()
         std::exit(EXIT_FAILURE);
     }
     Assert(!g_test_one_input);
-    g_test_one_input = &std::get<0>(it->second);
-    std::get<1>(it->second)();
+    g_test_one_input = &it->second.test_one_input;
+    it->second.opts.init();
 }
 
 #if defined(PROVIDE_FUZZ_MAIN_FUNCTION)

src/test/fuzz/fuzz.h

@@ -21,25 +21,25 @@
 using FuzzBufferType = Span<const uint8_t>;
 
 using TypeTestOneInput = std::function<void(FuzzBufferType)>;
-using TypeInitialize = std::function<void()>;
-using TypeHidden = bool;
+struct FuzzTargetOptions {
+    std::function<void()> init{[] {}};
+    bool hidden{false};
+};
 
-void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, TypeInitialize init, TypeHidden hidden);
+void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, FuzzTargetOptions opts);
 
-inline void FuzzFrameworkEmptyInitFun() {}
+#if defined(__clang__)
+#define FUZZ_TARGET(...) _Pragma("clang diagnostic push") _Pragma("clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"") DETAIL_FUZZ(__VA_ARGS__) _Pragma("clang diagnostic pop")
+#else
+#define FUZZ_TARGET(...) DETAIL_FUZZ(__VA_ARGS__)
+#endif
 
-#define FUZZ_TARGET(name) \
-    FUZZ_TARGET_INIT(name, FuzzFrameworkEmptyInitFun)
-
-#define FUZZ_TARGET_INIT(name, init_fun) \
-    FUZZ_TARGET_INIT_HIDDEN(name, init_fun, false)
-
-#define FUZZ_TARGET_INIT_HIDDEN(name, init_fun, hidden)                               \
+#define DETAIL_FUZZ(name, ...)                                                        \
     void name##_fuzz_target(FuzzBufferType);                                          \
     struct name##_Before_Main {                                                       \
         name##_Before_Main()                                                          \
         {                                                                             \
-            FuzzFrameworkRegisterTarget(#name, name##_fuzz_target, init_fun, hidden); \
+            FuzzFrameworkRegisterTarget(#name, name##_fuzz_target, {__VA_ARGS__});    \
         }                                                                             \
     } const static g_##name##_before_main;                                            \
     void name##_fuzz_target(FuzzBufferType buffer)

src/test/fuzz/i2p.cpp

@@ -17,7 +17,7 @@ void initialize_i2p()
     static const auto testing_setup = MakeNoLogFileContext<>();
 }
 
-FUZZ_TARGET_INIT(i2p, initialize_i2p)
+FUZZ_TARGET(i2p, .init = initialize_i2p)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
 

src/test/fuzz/integer.cpp

@@ -47,7 +47,7 @@ void initialize_integer()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(integer, initialize_integer)
+FUZZ_TARGET(integer, .init = initialize_integer)
 {
     if (buffer.size() < sizeof(uint256) + sizeof(uint160)) {
         return;

src/test/fuzz/key.cpp

@@ -33,7 +33,7 @@ void initialize_key()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(key, initialize_key)
+FUZZ_TARGET(key, .init = initialize_key)
 {
     const CKey key = [&] {
         CKey k;
@@ -261,7 +261,7 @@ FUZZ_TARGET_INIT(key, initialize_key)
     }
 }
 
-FUZZ_TARGET_INIT(ellswift_roundtrip, initialize_key)
+FUZZ_TARGET(ellswift_roundtrip, .init = initialize_key)
 {
     FuzzedDataProvider fdp{buffer.data(), buffer.size()};
 
@@ -280,7 +280,7 @@ FUZZ_TARGET_INIT(ellswift_roundtrip, initialize_key)
     assert(decoded_pubkey.Verify(hash, sig));
 }
 
-FUZZ_TARGET_INIT(bip324_ecdh, initialize_key)
+FUZZ_TARGET(bip324_ecdh, .init = initialize_key)
 {
     FuzzedDataProvider fdp{buffer.data(), buffer.size()};
 

src/test/fuzz/key_io.cpp

@@ -19,7 +19,7 @@ void initialize_key_io()
     SelectParams(CBaseChainParams::MAIN);
 }
 
-FUZZ_TARGET_INIT(key_io, initialize_key_io)
+FUZZ_TARGET(key_io, .init = initialize_key_io)
 {
     const std::string random_string(buffer.begin(), buffer.end());
 

src/test/fuzz/load_external_block_file.cpp

@@ -23,7 +23,7 @@ void initialize_load_external_block_file()
     g_setup = testing_setup.get();
 }
 
-FUZZ_TARGET_INIT(load_external_block_file, initialize_load_external_block_file)
+FUZZ_TARGET(load_external_block_file, .init = initialize_load_external_block_file)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     FuzzedFileProvider fuzzed_file_provider = ConsumeFile(fuzzed_data_provider);

src/test/fuzz/message.cpp

@@ -22,7 +22,7 @@ void initialize_message()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(message, initialize_message)
+FUZZ_TARGET(message, .init = initialize_message)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const std::string random_message = fuzzed_data_provider.ConsumeRandomLengthString(1024);

src/test/fuzz/net.cpp

@@ -40,7 +40,7 @@ void initialize_net()
 // From src/test/fuzz/addrman.cpp
 extern NetGroupManager ConsumeNetGroupManager(FuzzedDataProvider& fuzzed_data_provider) noexcept;
 
-FUZZ_TARGET_INIT(net, initialize_net)
+FUZZ_TARGET(net, .init = initialize_net)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 

src/test/fuzz/p2p_transport_serialization.cpp

@@ -28,7 +28,7 @@ void initialize_p2p_transport_serialization()
     std::sort(g_all_messages.begin(), g_all_messages.end());
 }
 
-FUZZ_TARGET_INIT(p2p_transport_serialization, initialize_p2p_transport_serialization)
+FUZZ_TARGET(p2p_transport_serialization, .init = initialize_p2p_transport_serialization)
 {
     // Construct transports for both sides, with dummy NodeIds.
     V1Transport recv_transport{NodeId{0}, SER_NETWORK, INIT_PROTO_VERSION};
@@ -370,7 +370,7 @@ std::unique_ptr<Transport> MakeV2Transport(NodeId nodeid, bool initiator, RNG& r
 
 } // namespace
 
-FUZZ_TARGET_INIT(p2p_transport_bidirectional, initialize_p2p_transport_serialization)
+FUZZ_TARGET(p2p_transport_bidirectional, .init = initialize_p2p_transport_serialization)
 {
     // Test with two V1 transports talking to each other.
     FuzzedDataProvider provider{buffer.data(), buffer.size()};
@@ -381,7 +381,7 @@ FUZZ_TARGET_INIT(p2p_transport_bidirectional, initialize_p2p_transport_serializa
     SimulationTest(*t1, *t2, rng, provider);
 }
 
-FUZZ_TARGET_INIT(p2p_transport_bidirectional_v2, initialize_p2p_transport_serialization)
+FUZZ_TARGET(p2p_transport_bidirectional_v2, .init = initialize_p2p_transport_serialization)
 {
     // Test with two V2 transports talking to each other.
     FuzzedDataProvider provider{buffer.data(), buffer.size()};
@@ -392,7 +392,7 @@ FUZZ_TARGET_INIT(p2p_transport_bidirectional_v2, initialize_p2p_transport_serial
     SimulationTest(*t1, *t2, rng, provider);
 }
 
-FUZZ_TARGET_INIT(p2p_transport_bidirectional_v1v2, initialize_p2p_transport_serialization)
+FUZZ_TARGET(p2p_transport_bidirectional_v1v2, .init = initialize_p2p_transport_serialization)
 {
     // Test with a V1 initiator talking to a V2 responder.
     FuzzedDataProvider provider{buffer.data(), buffer.size()};

src/test/fuzz/parse_univalue.cpp

@@ -18,7 +18,7 @@ void initialize_parse_univalue()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(parse_univalue, initialize_parse_univalue)
+FUZZ_TARGET(parse_univalue, .init = initialize_parse_univalue)
 {
     const std::string random_string(buffer.begin(), buffer.end());
     bool valid = true;

src/test/fuzz/policy_estimator.cpp

@@ -20,7 +20,7 @@ void initialize_policy_estimator()
     static const auto testing_setup = MakeNoLogFileContext<>();
 }
 
-FUZZ_TARGET_INIT(policy_estimator, initialize_policy_estimator)
+FUZZ_TARGET(policy_estimator, .init = initialize_policy_estimator)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     CBlockPolicyEstimator block_policy_estimator;

src/test/fuzz/policy_estimator_io.cpp

@@ -16,7 +16,7 @@ void initialize_policy_estimator_io()
     static const auto testing_setup = MakeNoLogFileContext<>();
 }
 
-FUZZ_TARGET_INIT(policy_estimator_io, initialize_policy_estimator_io)
+FUZZ_TARGET(policy_estimator_io, .init = initialize_policy_estimator_io)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     FuzzedAutoFileProvider fuzzed_auto_file_provider = ConsumeAutoFile(fuzzed_data_provider);

src/test/fuzz/pow.cpp

@@ -21,7 +21,7 @@ void initialize_pow()
     SelectParams(CBaseChainParams::MAIN);
 }
 
-FUZZ_TARGET_INIT(pow, initialize_pow)
+FUZZ_TARGET(pow, .init = initialize_pow)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const Consensus::Params& consensus_params = Params().GetConsensus();

src/test/fuzz/process_message.cpp

@@ -61,7 +61,7 @@ void initialize_process_message()
     SyncWithValidationInterfaceQueue();
 }
 
-FUZZ_TARGET_INIT(process_message, initialize_process_message)
+FUZZ_TARGET(process_message, .init = initialize_process_message)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 

src/test/fuzz/process_messages.cpp

@@ -33,7 +33,7 @@ void initialize_process_messages()
     SyncWithValidationInterfaceQueue();
 }
 
-FUZZ_TARGET_INIT(process_messages, initialize_process_messages)
+FUZZ_TARGET(process_messages, .init = initialize_process_messages)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
 

src/test/fuzz/rpc.cpp

@@ -337,7 +337,7 @@ void initialize_rpc()
     }
 }
 
-FUZZ_TARGET_INIT(rpc, initialize_rpc)
+FUZZ_TARGET(rpc, .init = initialize_rpc)
 {
     FuzzedDataProvider fuzzed_data_provider{buffer.data(), buffer.size()};
     SetMockTime(ConsumeTime(fuzzed_data_provider));

src/test/fuzz/script.cpp

@@ -33,7 +33,7 @@ void initialize_script()
     SelectParams(CBaseChainParams::REGTEST);
 }
 
-FUZZ_TARGET_INIT(script, initialize_script)
+FUZZ_TARGET(script, .init = initialize_script)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());
     const CScript script{ConsumeScript(fuzzed_data_provider)};

src/test/fuzz/script_sigcache.cpp

@@ -23,7 +23,7 @@ void initialize_script_sigcache()
     InitSignatureCache();
 }
 
-FUZZ_TARGET_INIT(script_sigcache, initialize_script_sigcache)
+FUZZ_TARGET(script_sigcache, .init = initialize_script_sigcache)
 {
     FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size());