Fix rocprof-sys-instrument default linkage and visibility criteria (#95)

* Fix default linkage and visibility criteria
* Fix processing of linkage and visibility CLI flags
* Format source

Signed-off-by: Wileam Yonatan Phan <wileamyonatan.phan@amd.com>
Signed-off-by: David Galiffi <David.Galiffi@amd.com>
Co-authored-by: David Galiffi <David.Galiffi@amd.com>

[ROCm/rocprofiler-systems commit: 2805631ccd]

projects/rocprofiler-systems/source/bin/rocprof-sys-instrument/rocprof-sys-instrument.cpp

@@ -143,10 +143,14 @@ regexvec_t       file_internal_include         = {};
 regexvec_t       instruction_exclude           = {};
 CodeCoverageMode coverage_mode                 = CODECOV_NONE;
 
-symtab_data_s                 symtab_data        = {};
-std::set<symbol_linkage_t>    enabled_linkage    = { SL_GLOBAL, SL_LOCAL, SL_UNIQUE };
-std::set<symbol_visibility_t> enabled_visibility = { SV_DEFAULT, SV_HIDDEN, SV_INTERNAL,
-                                                     SV_PROTECTED };
+symtab_data_s                       symtab_data                = {};
+std::set<symbol_linkage_t>          enabled_linkage            = {};
+std::set<symbol_visibility_t>       enabled_visibility         = {};
+const std::set<symbol_linkage_t>    default_enabled_linkage    = { SL_GLOBAL, SL_LOCAL,
+                                                             SL_UNIQUE };
+const std::set<symbol_visibility_t> default_enabled_visibility = { SV_DEFAULT, SV_HIDDEN,
+                                                                   SV_INTERNAL,
+                                                                   SV_PROTECTED };
 
 std::unique_ptr<std::ofstream> log_ofs = {};
 
@@ -835,32 +839,45 @@ main(int argc, char** argv)
         return _ret;
     };
 
+    enabled_linkage = default_enabled_linkage;
     parser
-        .add_argument({ "--linkage" },
-                      join("",
-                           "Only instrument functions with specified linkage (default: ",
-                           join(array_config{ ", ", "", "" }, enabled_linkage), ")"))
+        .add_argument(
+            { "--linkage" },
+            join("", "Only instrument functions with specified linkage (default: ",
+                 join(array_config{ ", ", "", "" }, _get_strvec(default_enabled_linkage)),
+                 ")"))
         .min_count(1)
-        .choices(available_linkage)
-        .set_default(_get_strvec(enabled_linkage))
+        .choices(_get_strvec(available_linkage))
+        .set_default(_get_strvec(default_enabled_linkage))
         .action([](parser_t& p) {
-            enabled_linkage.clear();
-            for(const auto& itr : p.get<std::set<std::string>>("linkage"))
-                enabled_linkage.emplace(from_string<symbol_linkage_t>(itr));
+            auto selected_linkage = p.get<std::set<std::string>>("linkage");
+            if(!selected_linkage.empty())
+            {
+                enabled_linkage.clear();
+                for(const auto& itr : selected_linkage)
+                    enabled_linkage.emplace(from_string<symbol_linkage_t>(itr));
+            }
         });
 
+    enabled_visibility = default_enabled_visibility;
     parser
         .add_argument(
             { "--visibility" },
             join("", "Only instrument functions with specified visibility (default: ",
-                 join(array_config{ ", ", "", "" }, enabled_visibility), ")"))
+                 join(array_config{ ", ", "", "" },
+                      _get_strvec(default_enabled_visibility)),
+                 ")"))
         .min_count(1)
-        .choices(available_visibility)
-        .set_default(_get_strvec(enabled_visibility))
+        .choices(_get_strvec(available_visibility))
+        .set_default(_get_strvec(default_enabled_visibility))
         .action([](parser_t& p) {
-            enabled_visibility.clear();
-            for(const auto& itr : p.get<std::set<std::string>>("visibility"))
-                enabled_visibility.emplace(from_string<symbol_visibility_t>(itr));
+            auto selected_visibility = p.get<std::set<std::string>>("visibility");
+            if(!selected_visibility.empty())
+            {
+                enabled_visibility.clear();
+                for(const auto& itr : selected_visibility)
+                    enabled_visibility.emplace(from_string<symbol_visibility_t>(itr));
+            }
         });
 
     parser.add_argument({ "" }, "");