Remove compiler warnings (#153)

Author: ahueck

lib/passes/TypeARTConfiguration.h

@@ -30,7 +30,7 @@ class CommandLineOptions;
 
 namespace env {
 class EnvironmentFlagsOptions;
-}
+}  // namespace env
 
 class TypeARTConfiguration final : public Configuration {
  private:

lib/passes/TypeARTPass.cpp

@@ -24,6 +24,7 @@
 #include "instrumentation/TypeARTFunctions.h"
 #include "support/Logger.h"
 #include "support/Table.h"
+#include "support/Util.h"
 #include "typegen/TypeGenerator.h"
 
 #include "llvm/ADT/DenseMap.h"
@@ -126,11 +127,11 @@ class TypeArtPass : public llvm::PassInfoMixin<TypeArtPass> {
                           ? config::TypeARTConfigInit{config_file_path.value()}
                           : config::TypeARTConfigInit{{}, config::TypeARTConfigInit::FileConfigurationMode::Empty};
 
-    auto typeart_config = [&](const auto& init) {
-      if (init.mode == config::TypeARTConfigInit::FileConfigurationMode::Empty) {
+    auto typeart_config = [&](const auto& init_value) {
+      if (init_value.mode == config::TypeARTConfigInit::FileConfigurationMode::Empty) {
         return config::make_typeart_configuration_from_opts(pass_opts.value_or(config::TypeARTConfigOptions{}));
       }
-      return config::make_typeart_configuration(init);
+      return config::make_typeart_configuration(init_value);
     }(init);
 
     if (typeart_config) {
@@ -250,8 +251,8 @@ class TypeArtPass : public llvm::PassInfoMixin<TypeArtPass> {
     };
 
     Table stats("TypeArtPass");
-    stats.wrap_header = true;
-    stats.title += get_ta_mode();
+    stats.wrap_header_ = true;
+    stats.title_ += get_ta_mode();
     stats.put(Row::make("Malloc", NumInstrumentedMallocs.getValue()));
     stats.put(Row::make("Free", NumInstrumentedFrees.getValue()));
     stats.put(Row::make("Alloca", NumInstrumentedAlloca.getValue()));
@@ -292,7 +293,7 @@ class TypeArtPass : public llvm::PassInfoMixin<TypeArtPass> {
   bool runOnFunc(llvm::Function& f) {
     using namespace typeart;
 
-    if (f.isDeclaration() || f.getName().startswith("__typeart")) {
+    if (f.isDeclaration() || util::starts_with_any_of(f.getName(), "__typeart")) {
       return false;
     }
 

lib/passes/analysis/MemInstFinder.cpp

@@ -117,28 +117,28 @@ static std::unique_ptr<typeart::filter::Filter> make_filter(const MemInstFinderC
 CallFilter::CallFilter(const MemInstFinderConfig& config) : fImpl{detail::make_filter(config)} {
 }
 
-bool CallFilter::operator()(AllocaInst* in) {
-  LOG_DEBUG("Analyzing value: " << util::dump(*in));
+bool CallFilter::operator()(AllocaInst* allocation) {
+  LOG_DEBUG("Analyzing value: " << util::dump(*allocation));
   fImpl->setMode(/*search mallocs = */ false);
-  fImpl->setStartingFunction(in->getParent()->getParent());
-  const auto filter_ = fImpl->filter(in);
+  fImpl->setStartingFunction(allocation->getParent()->getParent());
+  const auto filter_ = fImpl->filter(allocation);
   if (filter_) {
-    LOG_DEBUG("Filtering value: " << util::dump(*in) << "\n");
+    LOG_DEBUG("Filtering value: " << util::dump(*allocation) << "\n");
   } else {
-    LOG_DEBUG("Keeping value: " << util::dump(*in) << "\n");
+    LOG_DEBUG("Keeping value: " << util::dump(*allocation) << "\n");
   }
   return filter_;
 }
 
-bool CallFilter::operator()(GlobalValue* g) {
-  LOG_DEBUG("Analyzing value: " << util::dump(*g));
+bool CallFilter::operator()(GlobalValue* global_value) {
+  LOG_DEBUG("Analyzing value: " << util::dump(*global_value));
   fImpl->setMode(/*search mallocs = */ false);
   fImpl->setStartingFunction(nullptr);
-  const auto filter_ = fImpl->filter(g);
+  const auto filter_ = fImpl->filter(global_value);
   if (filter_) {
-    LOG_DEBUG("Filtering value: " << util::dump(*g) << "\n");
+    LOG_DEBUG("Filtering value: " << util::dump(*global_value) << "\n");
   } else {
-    LOG_DEBUG("Keeping value: " << util::dump(*g) << "\n");
+    LOG_DEBUG("Keeping value: " << util::dump(*global_value) << "\n");
   }
   return filter_;
 }
@@ -410,9 +410,9 @@ void MemInstFinderPass::printStats(llvm::raw_ostream& out) const {
       (double(NumFilteredGlobals) / std::max(1.0, double(NumDetectedGlobals))) * 100.0;
 
   Table stats("MemInstFinderPass");
-  stats.wrap_header = true;
-  stats.wrap_length = true;
-  std::string glob  = config[config::ConfigStdArgs::filter_glob];
+  stats.wrap_header_ = true;
+  stats.wrap_length_ = true;
+  std::string glob   = config[config::ConfigStdArgs::filter_glob];
   stats.put(Row::make("Filter string", glob));
   stats.put(Row::make_row("> Heap Memory"));
   stats.put(Row::make("Heap alloc", NumDetectedHeap.getValue()));

lib/passes/analysis/MemOpVisitor.cpp

@@ -53,16 +53,15 @@ MemOpVisitor::MemOpVisitor() : MemOpVisitor(true, true) {
 MemOpVisitor::MemOpVisitor(const config::Configuration& config)
     : MemOpVisitor(config[config::ConfigStdArgs::stack], config[config::ConfigStdArgs::heap]) {
 }
-MemOpVisitor::MemOpVisitor(bool collect_allocas, bool collect_heap)
-    : collect_allocas(collect_allocas), collect_heap(collect_heap) {
+MemOpVisitor::MemOpVisitor(bool stack, bool heap) : collect_allocas(stack), collect_heap(heap) {
 }
 
 void MemOpVisitor::collect(llvm::Function& function) {
   visit(function);
 
   for (auto& [lifetime, alloc] : lifetime_starts) {
-    auto* data =
-        llvm::find_if(allocas, [alloc = std::ref(alloc)](const AllocaData& data) { return data.alloca == alloc; });
+    auto* data = llvm::find_if(
+        allocas, [alloc = std::ref(alloc)](const AllocaData& alloca_data) { return alloca_data.alloca == alloc; });
     if (data != std::end(allocas)) {
       data->lifetime_start.insert(lifetime);
     }
@@ -132,11 +131,11 @@ llvm::Expected<T*> getSingleUserAs(llvm::Value* value) {
                   "Expected a single user on value \"{}\" but found multiple potential candidates!", *value);
 
   // This should return the type T we need:
-  auto user = llvm::find_if(users, [](auto user) { return isa<T>(*user); });
-  RETURN_ERROR_IF(user == std::end(users),
+  auto found_user = llvm::find_if(users, [](auto user) { return isa<T>(*user); });
+  RETURN_ERROR_IF(found_user == std::end(users),
                   "Expected a single user on value \"{}\" but didn't find a user of the desired type!", *value);
 
-  return {dyn_cast<T>(*user)};
+  return {dyn_cast<T>(*found_user)};
 }
 
 using MallocGeps   = SmallPtrSet<GetElementPtrInst*, 2>;

lib/passes/analysis/MemOpVisitor.h

@@ -43,7 +43,7 @@ struct MemOpVisitor : public llvm::InstVisitor<MemOpVisitor> {
  public:
   MemOpVisitor();
   explicit MemOpVisitor(const config::Configuration& config);
-  MemOpVisitor(bool collect_allocas, bool collect_heap);
+  MemOpVisitor(bool stack, bool heap);
   void collect(llvm::Function& function);
   void collectGlobals(llvm::Module& module);
   void clear();

lib/passes/filter/FilterBase.h

@@ -41,17 +41,17 @@ enum class FilterAnalysis {
 
 template <typename CallSiteHandler, typename Search, typename OmpHelper = omp::EmptyContext>
 class BaseFilter : public Filter {
-  CallSiteHandler handler;
+  CallSiteHandler callsite_handler;
   Search search_dir{};
   bool malloc_mode{false};
   llvm::Function* start_f{nullptr};
 
  public:
-  explicit BaseFilter(const CallSiteHandler& handler) : handler(handler) {
+  explicit BaseFilter(const CallSiteHandler& handler) : callsite_handler(handler) {
   }
 
   template <typename... Args>
-  explicit BaseFilter(Args&&... args) : handler(std::forward<Args>(args)...) {
+  explicit BaseFilter(Args&&... args) : callsite_handler(std::forward<Args>(args)...) {
   }
 
   bool filter(llvm::Value* in) override {
@@ -83,7 +83,7 @@ class BaseFilter : public Filter {
       // is null in case of global:
       llvm::Function* currentF = fpath.getCurrentFunc();
       if (currentF != nullptr) {
-        auto status = handler.precheck(current, currentF, fpath);
+        auto status = callsite_handler.precheck(current, currentF, fpath);
         switch (status) {
           case FilterAnalysis::Filter:
             fpath.pop();
@@ -232,7 +232,7 @@ class BaseFilter : public Filter {
       // Indirect calls (sth. like function pointers)
       if (indirect_call) {
         if constexpr (CallSiteHandler::Support::Indirect) {
-          auto status = handler.indirect(site, path);
+          auto status = callsite_handler.indirect(site, path);
           LOG_DEBUG("Indirect call: " << util::try_demangle(site))
           return status;
         } else {
@@ -248,7 +248,7 @@ class BaseFilter : public Filter {
       if (is_decl) {
         if (is_intrinsic) {
           if constexpr (CallSiteHandler::Support::Intrinsic) {
-            auto status = handler.intrinsic(site, path);
+            auto status = callsite_handler.intrinsic(site, path);
             LOG_DEBUG("Intrinsic call: " << util::try_demangle(site))
             return status;
           } else {
@@ -272,7 +272,7 @@ class BaseFilter : public Filter {
 
         // Handle decl (like MPI calls)
         if constexpr (CallSiteHandler::Support::Declaration) {
-          auto status = handler.decl(site, path);
+          auto status = callsite_handler.decl(site, path);
           LOG_DEBUG("Decl call: " << util::try_demangle(site))
           return status;
         } else {
@@ -282,7 +282,7 @@ class BaseFilter : public Filter {
       } else {
         // Handle definitions
         if constexpr (CallSiteHandler::Support::Definition) {
-          auto status = handler.def(site, path);
+          auto status = callsite_handler.def(site, path);
           LOG_DEBUG("Defined call: " << util::try_demangle(site))
           return status;
         } else {

lib/passes/filter/FilterUtil.h

@@ -160,11 +160,11 @@ inline bool isTempAlloc(llvm::Value* in) {
         for (auto& args : f->args()) {
           if (&args == store->getValueOperand()) {
             match = true;
-            return util::DefUseChain::cancel;
+            return util::DefUseChain::kCancel;
           }
         }
       }
-      return util::DefUseChain::no_match;
+      return util::DefUseChain::kNoMatch;
     });
 
     return match;

lib/passes/filter/Matcher.h

@@ -75,7 +75,7 @@ class FunctionOracleMatcher final : public Matcher {
     const auto f = c.getCalledFunction();
     if (f != nullptr) {
       const auto f_name = util::demangle(f->getName());
-      StringRef f_name_ref{f_name};
+      llvm::StringRef f_name_ref{f_name};
       if (continue_set.count(f_name) > 0) {
         return MatchResult::ShouldContinue;
       }

lib/passes/filter/OmpUtil.h

@@ -145,10 +145,10 @@ struct OmpContext {
 
             if (called != nullptr && util::starts_with_any_of(called->getName(), "__kmpc_omp_task(")) {
               found = true;
-              return util::DefUseChain::cancel;
+              return util::DefUseChain::kCancel;
             }
           }
-          return util::DefUseChain::no_match;
+          return util::DefUseChain::kNoMatch;
         });
     return found;
   }
@@ -170,9 +170,9 @@ struct OmpContext {
         auto calls = util::find_all(f, [&](auto& inst) {
           llvm::CallSite s(&inst);
           if (s.isCall() || s.isInvoke()) {
-            if (auto f = s.getCalledFunction()) {
+            if (auto called_function = s.getCalledFunction()) {
               // once true, the find_all should cancel
-              return util::starts_with_any_of(f->getName(), "__kmpc_omp_task_alloc");
+              return util::starts_with_any_of(called_function->getName(), "__kmpc_omp_task_alloc");
             }
           }
           return false;
@@ -184,9 +184,9 @@ struct OmpContext {
           chain.traverse(i, [&v, &found](auto val) {
             if (v == val) {
               found = true;
-              return util::DefUseChain::cancel;
+              return util::DefUseChain::kCancel;
             }
-            return util::DefUseChain::no_match;
+            return util::DefUseChain::kNoMatch;
           });
           if (found) {
             return true;

lib/passes/instrumentation/TypeARTFunctions.cpp

@@ -37,21 +37,22 @@ using namespace llvm;
 
 namespace typeart {
 
-TAFunctionDeclarator::TAFunctionDeclarator(Module& m, InstrumentationHelper&, TAFunctions& tafunc)
-    : m(m), tafunc(tafunc) {
+TAFunctionDeclarator::TAFunctionDeclarator(Module& mod, InstrumentationHelper&, TAFunctions& typeart_funcs)
+    : module(mod), typeart_functions(typeart_funcs) {
 }
 
-llvm::Function* TAFunctionDeclarator::make_function(IFunc id, llvm::StringRef basename,
+llvm::Function* TAFunctionDeclarator::make_function(IFunc func_id, llvm::StringRef basename,
                                                     llvm::ArrayRef<llvm::Type*> args, bool with_omp, bool fixed_name) {
-  const auto make_fname = [&fixed_name](llvm::StringRef name, llvm::ArrayRef<llvm::Type*> args, bool with_omp) {
+  const auto make_fname = [&fixed_name](llvm::StringRef name, llvm::ArrayRef<llvm::Type*> callback_arguments,
+                                        bool with_omp_postfix) {
     std::string fname;
     llvm::raw_string_ostream os(fname);
     os << name;
 
     if (!fixed_name) {
-      os << "_" << std::to_string(args.size());
+      os << "_" << std::to_string(callback_arguments.size());
     }
-    if (with_omp) {
+    if (with_omp_postfix) {
       os << "_"
          << "omp";
     }
@@ -60,11 +61,11 @@ llvm::Function* TAFunctionDeclarator::make_function(IFunc id, llvm::StringRef ba
 
   const auto name = make_fname(basename, args, with_omp);
 
-  if (auto it = f_map.find(name); it != f_map.end()) {
+  if (auto it = function_map.find(name); it != function_map.end()) {
     return it->second;
   }
 
-  auto& c                           = m.getContext();
+  auto& c                           = module.getContext();
   const auto addOptimizerAttributes = [&](llvm::Function* function) {
     function->setDoesNotThrow();
     function->setDoesNotFreeMemory();
@@ -84,13 +85,13 @@ llvm::Function* TAFunctionDeclarator::make_function(IFunc id, llvm::StringRef ba
     function->setLinkage(GlobalValue::ExternalLinkage);
     //     f->setLinkage(GlobalValue::ExternalWeakLinkage);
   };
-  const auto do_make = [&](auto& name, auto f_type) {
-    const bool has_func_declared = m.getFunction(name) != nullptr;
-    auto func_in_module          = m.getOrInsertFunction(name, f_type);
+  const auto do_make = [&](auto& function_name, auto function_type) {
+    const bool has_func_declared = module.getFunction(function_name) != nullptr;
+    auto func_in_module          = module.getOrInsertFunction(function_name, function_type);
 
     Function* function{nullptr};
     if (has_func_declared) {
-      LOG_WARNING("Function " << name << " is already declared in the module.")
+      LOG_WARNING("Function " << function_name << " is already declared in the module.")
       function = dyn_cast<Function>(func_in_module.getCallee()->stripPointerCasts());
     } else {
       function = dyn_cast<Function>(func_in_module.getCallee());
@@ -101,17 +102,17 @@ llvm::Function* TAFunctionDeclarator::make_function(IFunc id, llvm::StringRef ba
     return function;
   };
 
-  auto f = do_make(name, FunctionType::get(Type::getVoidTy(c), args, false));
+  auto generated_function = do_make(name, FunctionType::get(Type::getVoidTy(c), args, false));
 
-  f_map[name] = f;
+  function_map[name] = generated_function;
 
-  tafunc.putFunctionFor(id, f);
+  typeart_functions.putFunctionFor(func_id, generated_function);
 
-  return f;
+  return generated_function;
 }
 
 const llvm::StringMap<llvm::Function*>& TAFunctionDeclarator::getFunctionMap() const {
-  return f_map;
+  return function_map;
 }
 
 TAFunctions::TAFunctions() = default;