25177145272

Committed 30 Apr 2026 04:30PM UTC coverage: 84.647% (-5.6%) from 90.246%

Build # 25177145272

Build Type

Pull #188

github

Committed by

web-flow

Commit Message

Merge 88918912c into 278119205

Pull Request Pull Request #188: GPU memory allocation support

Coverage Stats

127 of 259 new or added lines in 19 files covered. (49.03%)

200 existing lines in 18 files now uncovered.

4510 of 5328 relevant lines covered (84.65%)

27776.73 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.1

/lib/passes/analysis/MemInstFinder.cpp

// TypeART library
//
// Copyright (c) 2017-2026 TypeART Authors
// Distributed under the BSD 3-Clause license.
// (See accompanying file LICENSE.txt or copy at
// https://opensource.org/licenses/BSD-3-Clause)
//
// Project home: https://github.com/tudasc/TypeART
//
// SPDX-License-Identifier: BSD-3-Clause
//

#include "MemInstFinder.h"

#include "MemOpVisitor.h"
#include "TypeARTConfiguration.h"
#include "analysis/MemOpData.h"
#include "configuration/Configuration.h"
#include "configuration/TypeARTOptions.h"
#include "filter/CGForwardFilter.h"
#include "filter/CGInterface.h"
#include "filter/Filter.h"
#include "filter/Matcher.h"
#include "filter/StdForwardFilter.h"
#include "support/ConfigurationBase.h"
#include "support/Logger.h"
#include "support/Table.h"
#include "support/TypeUtil.h"
#include "support/Util.h"

#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/BasicBlock.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/GlobalValue.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/raw_ostream.h"

#include <algorithm>
#include <cstdlib>
#include <llvm/ADT/ScopeExit.h>
#include <sstream>
#include <string>
#include <utility>

using namespace llvm;

#define DEBUG_TYPE "MemInstFinder"
ALWAYS_ENABLED_STATISTIC(NumDetectedHeap, "Number of detected heap allocs");
ALWAYS_ENABLED_STATISTIC(NumFilteredDetectedHeap, "Number of filtered heap allocs");
ALWAYS_ENABLED_STATISTIC(NumDetectedAllocs, "Number of detected allocs");
ALWAYS_ENABLED_STATISTIC(NumFilteredPointerAllocs, "Number of filtered pointer allocs");
ALWAYS_ENABLED_STATISTIC(NumCallFilteredAllocs, "Number of call filtered allocs");
ALWAYS_ENABLED_STATISTIC(NumFilteredMallocAllocs, "Number of  filtered  malloc-related allocs");
ALWAYS_ENABLED_STATISTIC(NumFilteredNonArrayAllocs, "Number of filtered non-array allocs");
ALWAYS_ENABLED_STATISTIC(NumDetectedGlobals, "Number of detected globals");
ALWAYS_ENABLED_STATISTIC(NumFilteredGlobals, "Number of filtered globals");
ALWAYS_ENABLED_STATISTIC(NumCallFilteredGlobals, "Number of filtered globals");

namespace typeart::analysis {

using MemInstFinderConfig = config::Configuration;

namespace filter {
class CallFilter {
  std::unique_ptr<typeart::filter::Filter> fImpl;

 public:
  explicit CallFilter(const MemInstFinderConfig& config);
  CallFilter(const CallFilter&) = delete;
  CallFilter(CallFilter&&)      = default;
  bool operator()(llvm::AllocaInst*);
  bool operator()(llvm::GlobalValue*);
  CallFilter& operator=(CallFilter&&) noexcept;
  CallFilter& operator=(const CallFilter&) = delete;
  virtual ~CallFilter();
};

}  // namespace filter

namespace filter {

namespace detail {
static std::unique_ptr<typeart::filter::Filter> make_filter(const MemInstFinderConfig& config) {
  using namespace typeart::filter;
  const bool filter                    = config[config::ConfigStdArgs::filter];
  const FilterImplementation filter_id = config[config::ConfigStdArgs::filter_impl];
  const std::string glob               = config[config::ConfigStdArgs::filter_glob];

  if (filter_id == FilterImplementation::none || !filter) {
    LOG_DEBUG("Return no-op filter")
    return std::make_unique<NoOpFilter>();
  } else if (filter_id == FilterImplementation::cg) {
    const std::string cg_file = config[config::ConfigStdArgs::filter_cg_file];
    if (cg_file.empty()) {
      LOG_FATAL("CG File not set!");
      std::exit(1);
    }
    LOG_DEBUG("Return CG filter with CG file @ " << cg_file)
    auto json_cg = JSONCG::getJSON(cg_file);
    auto matcher = std::make_unique<DefaultStringMatcher>(util::glob2regex(glob));
    return std::make_unique<CGForwardFilter>(glob, std::move(json_cg), std::move(matcher));
  } else {
    LOG_DEBUG("Return default filter")
    auto matcher         = std::make_unique<DefaultStringMatcher>(util::glob2regex(glob));
    const auto deep_glob = config[config::ConfigStdArgs::filter_glob_deep];
    auto deep_matcher    = std::make_unique<DefaultStringMatcher>(util::glob2regex(deep_glob));
    return std::make_unique<StandardForwardFilter>(std::move(matcher), std::move(deep_matcher));
  }
}
}  // namespace detail

CallFilter::CallFilter(const MemInstFinderConfig& config) : fImpl{detail::make_filter(config)} {
}

bool CallFilter::operator()(AllocaInst* allocation) {
  LOG_DEBUG("Analyzing value: " << util::dump(*allocation));
  fImpl->setMode(/*search mallocs = */ false);
  fImpl->setStartingFunction(allocation->getParent()->getParent());
  const auto filter_ = fImpl->filter(allocation);
  if (filter_) {
    LOG_DEBUG("Filtering value: " << util::dump(*allocation) << "\n");
  } else {
    LOG_DEBUG("Keeping value: " << util::dump(*allocation) << "\n");
  }
  return filter_;
}

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(global_value);
  if (filter_) {
    LOG_DEBUG("Filtering value: " << util::dump(*global_value) << "\n");
  } else {
    LOG_DEBUG("Keeping value: " << util::dump(*global_value) << "\n");
  }
  return filter_;
}

CallFilter& CallFilter::operator=(CallFilter&&) noexcept = default;

CallFilter::~CallFilter() = default;

}  // namespace filter

class MemInstFinderPass : public MemInstFinder {
 private:
  MemOpVisitor mOpsCollector;
  filter::CallFilter filter;
  llvm::DenseMap<const llvm::Function*, FunctionData> functionMap;
  const MemInstFinderConfig& config;

 public:
  explicit MemInstFinderPass(const MemInstFinderConfig&);
  bool runOnModule(llvm::Module&) override;
  [[nodiscard]] bool hasFunctionData(const llvm::Function&) const override;
  [[nodiscard]] const FunctionData& getFunctionData(const llvm::Function&) const override;
  const GlobalDataList& getModuleGlobals() const override;
  void printStats(llvm::raw_ostream&) const override;
  // void configure(MemInstFinderConfig&) override;
  ~MemInstFinderPass() override = default;

 private:
  bool runOnFunction(llvm::Function&);
};

MemInstFinderPass::MemInstFinderPass(const MemInstFinderConfig& conf_)
    : mOpsCollector(conf_), filter(conf_), config(conf_) {
}

bool MemInstFinderPass::runOnModule(Module& module) {
  mOpsCollector.collectGlobals(module);
  auto& globals = mOpsCollector.globals;
  NumDetectedGlobals += globals.size();
  if (config[config::ConfigStdArgs::analysis_filter_global]) {
    globals.erase(
        llvm::remove_if(
            globals,
            [&](const auto gdata) {  // NOLINT
              GlobalVariable* global = gdata.global;
              const auto name        = global->getName();

              LOG_DEBUG("Analyzing global: " << name);

              if (name.empty()) {
                return true;
              }

              if (util::starts_with_any_of(name, "llvm.", "__llvm_gcov", "__llvm_gcda", "__profn", "___asan", "__msan",
                                           "__tsan", "__typeart", "_typeart", "__tysan", "__dfsan", "__profc")) {
                LOG_DEBUG("Prefixed matched on " << name)
                return true;
              }

              if (global->hasInitializer()) {
                auto* ini            = global->getInitializer();
                std::string ini_name = util::dump(*ini);

                if (llvm::StringRef(ini_name).contains("std::ios_base::Init")) {
                  LOG_DEBUG("std::ios");
                  return true;
                }
              }

              if (global->hasSection()) {
                // for instance, filters:
                //   a) (Coverage) -fprofile-instr-generate -fcoverage-mapping
                //   b) (PGO) -fprofile-instr-generate
                StringRef Section = global->getSection();
                // Globals from llvm.metadata aren't emitted, do not instrument them.
                if (Section == "llvm.metadata") {
                  LOG_DEBUG("metadata");
                  return true;
                }
                // Do not instrument globals from special LLVM sections.
                if (Section.find("__llvm") != StringRef::npos || Section.find("__LLVM") != StringRef::npos) {
                  LOG_DEBUG("llvm section");
                  return true;
                }
              }

              if ((global->getLinkage() == GlobalValue::ExternalLinkage && global->isDeclaration())) {
                LOG_DEBUG("Linkage: External");
                return true;
              }

              Type* global_type = global->getValueType();
              if (!global_type->isSized()) {
                LOG_DEBUG("not sized");
                return true;
              }

              if (global_type->isArrayTy()) {
                global_type = global_type->getArrayElementType();
              }
              if (auto structType = dyn_cast<StructType>(global_type)) {
                if (structType->isOpaque()) {
                  LOG_DEBUG("Encountered opaque struct " << global_type->getStructName() << " - skipping...");
                  return true;
                }
              }
              return false;
            }),
        globals.end());

    const auto beforeCallFilter = globals.size();
    NumFilteredGlobals          = NumDetectedGlobals - beforeCallFilter;

    globals.erase(llvm::remove_if(globals, [&](const auto global) { return filter(global.global); }), globals.end());

    NumCallFilteredGlobals = beforeCallFilter - globals.size();
    NumFilteredGlobals += NumCallFilteredGlobals;
  }

  return llvm::count_if(module.functions(), [&](auto& function) { return runOnFunction(function); }) > 0;
}  // namespace typeart

bool MemInstFinderPass::runOnFunction(llvm::Function& function) {
  if (function.isDeclaration() || util::starts_with_any_of(function.getName(), "__typeart")) {
    return false;
  }

  LOG_DEBUG("Running on function: " << function.getName())

  mOpsCollector.collect(function);

#if LLVM_VERSION_MAJOR < 15
  const auto checkAmbigiousMalloc = [&function](const MallocData& mallocData) {
    using namespace typeart::util::type;
    auto primaryBitcast = mallocData.primary;
    if (primaryBitcast != nullptr) {
      const auto& bitcasts = mallocData.bitcasts;
      std::for_each(bitcasts.begin(), bitcasts.end(), [&](auto bitcastInst) {
        auto dest = bitcastInst->getDestTy();
        if (bitcastInst != primaryBitcast &&
            (!isVoidPtr(dest) && !isi64Ptr(dest) &&
             primaryBitcast->getDestTy() != dest)) {  // void* and i64* are used by LLVM
          // Second non-void* bitcast detected - semantics unclear
          LOG_WARNING("Encountered ambiguous pointer type in function: " << util::try_demangle(function));
          LOG_WARNING("  Allocation" << util::dump(*(mallocData.call)));
          LOG_WARNING("  Primary cast: " << util::dump(*primaryBitcast));
          LOG_WARNING("  Secondary cast: " << util::dump(*bitcastInst));
        }
      });
    }
  };
#endif

  NumDetectedAllocs += mOpsCollector.allocas.size();

  if (config[config::ConfigStdArgs::analysis_filter_alloca_non_array]) {
    auto& allocs = mOpsCollector.allocas;
    allocs.erase(llvm::remove_if(allocs,
                                 [&](const auto& data) {
                                   if (!data.alloca->getAllocatedType()->isArrayTy() && data.array_size == 1) {
                                     ++NumFilteredNonArrayAllocs;
                                     return true;
                                   }
                                   return false;
                                 }),
                 allocs.end());
  }

  if (config[config::ConfigStdArgs::analysis_filter_heap_alloc]) {
    auto& allocs  = mOpsCollector.allocas;
    auto& mallocs = mOpsCollector.mallocs;

    const auto filterMallocAllocPairing = [&mallocs](const auto alloc) {
      // Only look for the direct users of the alloc:
      // TODO is a deeper analysis required?
      for (auto inst : alloc->users()) {
        if (StoreInst* store = dyn_cast<StoreInst>(inst)) {
          const auto source = store->getValueOperand();
          if (isa<BitCastInst>(source)) {
            for (auto& mdata : mallocs) {
              // is it a bitcast we already collected? if yes, we can filter the alloc
              return std::any_of(mdata.bitcasts.begin(), mdata.bitcasts.end(),
                                 [&source](const auto bcast) { return bcast == source; });
            }
          } else if (isa<CallInst>(source)) {
            return std::any_of(mallocs.begin(), mallocs.end(),
                               [&source](const auto& mdata) { return mdata.call == source; });
          }
        }
      }
      return false;
    };

    allocs.erase(llvm::remove_if(allocs,
                                 [&](const auto& data) {
                                   if (filterMallocAllocPairing(data.alloca)) {
                                     ++NumFilteredMallocAllocs;
                                     return true;
                                   }
                                   return false;
                                 }),
                 allocs.end());
  }

  if (config[config::ConfigStdArgs::analysis_filter_pointer_alloc]) {
    auto& allocs = mOpsCollector.allocas;
    allocs.erase(llvm::remove_if(allocs,
                                 [&](const auto& data) {
                                   auto alloca = data.alloca;
                                   if (!data.is_vla && isa<llvm::PointerType>(alloca->getAllocatedType())) {
                                     ++NumFilteredPointerAllocs;
                                     return true;
                                   }
                                   return false;
                                 }),
                 allocs.end());
  }

  // if (config.filter.useCallFilter) {
  if (config[config::ConfigStdArgs::filter]) {
    auto& allocs = mOpsCollector.allocas;
    allocs.erase(llvm::remove_if(allocs,
                                 [&](const auto& data) {
                                   if (filter(data.alloca)) {
                                     ++NumCallFilteredAllocs;
                                     return true;
                                   }
                                   return false;
                                 }),
                 allocs.end());
    //    LOG_DEBUG(allocs.size() << " allocas to instrument : " << util::dump(allocs));
  }

  auto& mallocs = mOpsCollector.mallocs;
  NumDetectedHeap += mallocs.size();

#if LLVM_VERSION_MAJOR < 15
  for (const auto& mallocData : mallocs) {
    checkAmbigiousMalloc(mallocData);
  }
#endif

  FunctionData data{mOpsCollector.mallocs, mOpsCollector.frees, mOpsCollector.allocas};
  functionMap[&function] = data;

  mOpsCollector.clear();

  return true;
}  // namespace typeart

void MemInstFinderPass::printStats(llvm::raw_ostream& out) const {
#if LLVM_VERSION_MAJOR < 22
  const auto scope_exit_cleanup_counter = llvm::make_scope_exit([&]() {
#else
  llvm::scope_exit scope_exit_cleanup_counter([&]() {
#endif
    NumDetectedAllocs         = 0;
    NumFilteredNonArrayAllocs = 0;
    NumFilteredMallocAllocs   = 0;
    NumCallFilteredAllocs     = 0;
    NumFilteredPointerAllocs  = 0;
    NumDetectedHeap           = 0;
    NumFilteredGlobals        = 0;
    NumDetectedGlobals        = 0;
  });
  auto all_stack            = double(NumDetectedAllocs);
  auto nonarray_stack       = double(NumFilteredNonArrayAllocs);
  auto malloc_alloc_stack   = double(NumFilteredMallocAllocs);
  auto call_filter_stack    = double(NumCallFilteredAllocs);
  auto filter_pointer_stack = double(NumFilteredPointerAllocs);

  const auto call_filter_stack_p =
      (call_filter_stack /
       std::max<double>(1.0, all_stack - nonarray_stack - malloc_alloc_stack - filter_pointer_stack)) *
      100.0;

  const auto call_filter_heap_p =
      (double(NumFilteredDetectedHeap) / std::max<double>(1.0, double(NumDetectedHeap))) * 100.0;

  const auto call_filter_global_p =
      (double(NumCallFilteredGlobals) / std::max(1.0, double(NumDetectedGlobals))) * 100.0;

  const auto call_filter_global_nocallfilter_p =
      (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.put(Row::make("Filter string", glob));
  stats.put(Row::make_row("> Heap Memory"));
  stats.put(Row::make("Heap alloc", NumDetectedHeap.getValue()));
  stats.put(Row::make("Heap call filtered %", call_filter_heap_p));
  stats.put(Row::make_row("> Stack Memory"));
  stats.put(Row::make("Alloca", all_stack));
  stats.put(Row::make("Stack call filtered %", call_filter_stack_p));
  stats.put(Row::make("Alloca of pointer discarded", filter_pointer_stack));
  stats.put(Row::make_row("> Global Memory"));
  stats.put(Row::make("Global", NumDetectedGlobals.getValue()));
  stats.put(Row::make("Global filter total", NumFilteredGlobals.getValue()));
  stats.put(Row::make("Global call filtered %", call_filter_global_p));
  stats.put(Row::make("Global filtered %", call_filter_global_nocallfilter_p));

  std::ostringstream stream;
  stats.print(stream);
  out << stream.str();
}

bool MemInstFinderPass::hasFunctionData(const Function& function) const {
  auto iter = functionMap.find(&function);
  return iter != functionMap.end();
}

const FunctionData& MemInstFinderPass::getFunctionData(const Function& function) const {
  auto iter = functionMap.find(&function);
  return iter->second;
}

const GlobalDataList& MemInstFinderPass::getModuleGlobals() const {
  return mOpsCollector.globals;
}

std::unique_ptr<MemInstFinder> create_finder(const config::Configuration& config) {
  LOG_DEBUG("Constructing MemInstFinder")
  // const auto meminst_conf = config::helper::config_to_options(config);
  return std::make_unique<MemInstFinderPass>(config);
}

}  // namespace typeart::analysis

1	// TypeART library
2	//
3	// Copyright (c) 2017-2026 TypeART Authors
4	// Distributed under the BSD 3-Clause license.
5	// (See accompanying file LICENSE.txt or copy at
6	// https://opensource.org/licenses/BSD-3-Clause)
7	//
8	// Project home: https://github.com/tudasc/TypeART
9	//
10	// SPDX-License-Identifier: BSD-3-Clause
11	//
12
13	#include "MemInstFinder.h"
14
15	#include "MemOpVisitor.h"
16	#include "TypeARTConfiguration.h"
17	#include "analysis/MemOpData.h"
18	#include "configuration/Configuration.h"
19	#include "configuration/TypeARTOptions.h"
20	#include "filter/CGForwardFilter.h"
21	#include "filter/CGInterface.h"
22	#include "filter/Filter.h"
23	#include "filter/Matcher.h"
24	#include "filter/StdForwardFilter.h"
25	#include "support/ConfigurationBase.h"
26	#include "support/Logger.h"
27	#include "support/Table.h"
28	#include "support/TypeUtil.h"
29	#include "support/Util.h"
30
31	#include "llvm/ADT/STLExtras.h"
32	#include "llvm/ADT/Statistic.h"
33	#include "llvm/ADT/StringRef.h"
34	#include "llvm/IR/BasicBlock.h"
35	#include "llvm/IR/DerivedTypes.h"
36	#include "llvm/IR/Function.h"
37	#include "llvm/IR/GlobalValue.h"
38	#include "llvm/IR/Instructions.h"
39	#include "llvm/IR/Module.h"
40	#include "llvm/IR/Type.h"
41	#include "llvm/Support/Casting.h"
42	#include "llvm/Support/raw_ostream.h"
43
44	#include <algorithm>
45	#include <cstdlib>
46	#include <llvm/ADT/ScopeExit.h>
47	#include <sstream>
48	#include <string>
49	#include <utility>
50
51	using namespace llvm;
52
53	#define DEBUG_TYPE "MemInstFinder"
54	ALWAYS_ENABLED_STATISTIC(NumDetectedHeap, "Number of detected heap allocs");
55	ALWAYS_ENABLED_STATISTIC(NumFilteredDetectedHeap, "Number of filtered heap allocs");
56	ALWAYS_ENABLED_STATISTIC(NumDetectedAllocs, "Number of detected allocs");
57	ALWAYS_ENABLED_STATISTIC(NumFilteredPointerAllocs, "Number of filtered pointer allocs");
58	ALWAYS_ENABLED_STATISTIC(NumCallFilteredAllocs, "Number of call filtered allocs");
59	ALWAYS_ENABLED_STATISTIC(NumFilteredMallocAllocs, "Number of filtered malloc-related allocs");
60	ALWAYS_ENABLED_STATISTIC(NumFilteredNonArrayAllocs, "Number of filtered non-array allocs");
61	ALWAYS_ENABLED_STATISTIC(NumDetectedGlobals, "Number of detected globals");
62	ALWAYS_ENABLED_STATISTIC(NumFilteredGlobals, "Number of filtered globals");
63	ALWAYS_ENABLED_STATISTIC(NumCallFilteredGlobals, "Number of filtered globals");
64
65	namespace typeart::analysis {
66
67	using MemInstFinderConfig = config::Configuration;
68
69	namespace filter {
70	class CallFilter {
71	std::unique_ptr<typeart::filter::Filter> fImpl;
72
73	public:
74	explicit CallFilter(const MemInstFinderConfig& config);
75	CallFilter(const CallFilter&) = delete;
76	CallFilter(CallFilter&&) = default;
77	bool operator()(llvm::AllocaInst*);
78	bool operator()(llvm::GlobalValue*);
79	CallFilter& operator=(CallFilter&&) noexcept;
80	CallFilter& operator=(const CallFilter&) = delete;
81	virtual ~CallFilter();
82	};
83
84	} // namespace filter
85
86	namespace filter {
87
88	namespace detail {
89	static std::unique_ptr<typeart::filter::Filter> make_filter(const MemInstFinderConfig& config) {	4,042✔
90	using namespace typeart::filter;
91	const bool filter = config[config::ConfigStdArgs::filter];	4,042✔
92	const FilterImplementation filter_id = config[config::ConfigStdArgs::filter_impl];	4,042✔
93	const std::string glob = config[config::ConfigStdArgs::filter_glob];	4,042✔
94
95	if (filter_id == FilterImplementation::none \|\| !filter) {	4,042✔
96	LOG_DEBUG("Return no-op filter")
97	return std::make_unique<NoOpFilter>();	3,700✔
98	} else if (filter_id == FilterImplementation::cg) {	342✔
99	const std::string cg_file = config[config::ConfigStdArgs::filter_cg_file];	30✔
100	if (cg_file.empty()) {	30✔
101	LOG_FATAL("CG File not set!");	×
102	std::exit(1);	×
103	}
104	LOG_DEBUG("Return CG filter with CG file @ " << cg_file)
105	auto json_cg = JSONCG::getJSON(cg_file);	30✔
106	auto matcher = std::make_unique<DefaultStringMatcher>(util::glob2regex(glob));	30✔
107	return std::make_unique<CGForwardFilter>(glob, std::move(json_cg), std::move(matcher));	30✔
108	} else {	30✔
109	LOG_DEBUG("Return default filter")
110	auto matcher = std::make_unique<DefaultStringMatcher>(util::glob2regex(glob));	312✔
111	const auto deep_glob = config[config::ConfigStdArgs::filter_glob_deep];	312✔
112	auto deep_matcher = std::make_unique<DefaultStringMatcher>(util::glob2regex(deep_glob));	312✔
113	return std::make_unique<StandardForwardFilter>(std::move(matcher), std::move(deep_matcher));	312✔
114	}	312✔
115	}	4,042✔
116	} // namespace detail
117
118	CallFilter::CallFilter(const MemInstFinderConfig& config) : fImpl{detail::make_filter(config)} {	4,042✔
119	}	4,042✔
120
121	bool CallFilter::operator()(AllocaInst* allocation) {	1,789✔
122	LOG_DEBUG("Analyzing value: " << util::dump(*allocation));
123	fImpl->setMode(/search mallocs = / false);	1,789✔
124	fImpl->setStartingFunction(allocation->getParent()->getParent());	1,789✔
125	const auto filter_ = fImpl->filter(allocation);	1,789✔
126	if (filter_) {	1,789✔
127	LOG_DEBUG("Filtering value: " << util::dump(*allocation) << "\n");
128	} else {	1,473✔
129	LOG_DEBUG("Keeping value: " << util::dump(*allocation) << "\n");
130	}
131	return filter_;	1,789✔
132	}
133
134	bool CallFilter::operator()(GlobalValue* global_value) {	16,583✔
135	LOG_DEBUG("Analyzing value: " << util::dump(*global_value));
136	fImpl->setMode(/search mallocs = / false);	16,583✔
137	fImpl->setStartingFunction(nullptr);	16,583✔
138	const auto filter_ = fImpl->filter(global_value);	16,583✔
139	if (filter_) {	16,583✔
140	LOG_DEBUG("Filtering value: " << util::dump(*global_value) << "\n");
141	} else {	390✔
142	LOG_DEBUG("Keeping value: " << util::dump(*global_value) << "\n");
143	}
144	return filter_;	16,583✔
145	}
146
147	CallFilter& CallFilter::operator=(CallFilter&&) noexcept = default;	×
148
149	CallFilter::~CallFilter() = default;	4,042✔
150
151	} // namespace filter
152
153	class MemInstFinderPass : public MemInstFinder {
154	private:
155	MemOpVisitor mOpsCollector;
156	filter::CallFilter filter;
157	llvm::DenseMap<const llvm::Function*, FunctionData> functionMap;
158	const MemInstFinderConfig& config;
159
160	public:
161	explicit MemInstFinderPass(const MemInstFinderConfig&);
162	bool runOnModule(llvm::Module&) override;
163	[[nodiscard]] bool hasFunctionData(const llvm::Function&) const override;
164	[[nodiscard]] const FunctionData& getFunctionData(const llvm::Function&) const override;
165	const GlobalDataList& getModuleGlobals() const override;
166	void printStats(llvm::raw_ostream&) const override;
167	// void configure(MemInstFinderConfig&) override;
168	~MemInstFinderPass() override = default;	8,084✔
169
170	private:
171	bool runOnFunction(llvm::Function&);
172	};
173
174	MemInstFinderPass::MemInstFinderPass(const MemInstFinderConfig& conf_)	8,084✔
175	: mOpsCollector(conf_), filter(conf_), config(conf_) {	8,084✔
176	}	4,042✔
177
178	bool MemInstFinderPass::runOnModule(Module& module) {	4,042✔
179	mOpsCollector.collectGlobals(module);	4,042✔
180	auto& globals = mOpsCollector.globals;	4,042✔
181	NumDetectedGlobals += globals.size();	4,042✔
182	if (config[config::ConfigStdArgs::analysis_filter_global]) {	4,042✔
183	globals.erase(	8,084✔
184	llvm::remove_if(	4,042✔
185	globals,	4,042✔
186	[&](const auto gdata) { // NOLINT	156,351✔
187	GlobalVariable* global = gdata.global;	156,351✔
188	const auto name = global->getName();	156,351✔
189
190	LOG_DEBUG("Analyzing global: " << name);
191
192	if (name.empty()) {	156,351✔
193	return true;	107,432✔
194	}
195
196	if (util::starts_with_any_of(name, "llvm.", "__llvm_gcov", "__llvm_gcda", "__profn", "___asan", "__msan",	48,919✔
197	"__tsan", "__typeart", "_typeart", "__tysan", "__dfsan", "__profc")) {
198	LOG_DEBUG("Prefixed matched on " << name)
199	return true;	31,076✔
200	}
201
202	if (global->hasInitializer()) {	17,843✔
203	auto* ini = global->getInitializer();	16,583✔
204	std::string ini_name = util::dump(*ini);	16,583✔
205
206	if (llvm::StringRef(ini_name).contains("std::ios_base::Init")) {	16,583✔
207	LOG_DEBUG("std::ios");
208	return true;	×
209	}
210	}	16,583✔
211
212	if (global->hasSection()) {	17,843✔
213	// for instance, filters:
214	// a) (Coverage) -fprofile-instr-generate -fcoverage-mapping
215	// b) (PGO) -fprofile-instr-generate
UNCOV 216	StringRef Section = global->getSection();	×
217	// Globals from llvm.metadata aren't emitted, do not instrument them.
UNCOV 218	if (Section == "llvm.metadata") {	×
219	LOG_DEBUG("metadata");
220	return true;	×
221	}
222	// Do not instrument globals from special LLVM sections.
UNCOV 223	if (Section.find("__llvm") != StringRef::npos \|\| Section.find("__LLVM") != StringRef::npos) {	×
224	LOG_DEBUG("llvm section");
UNCOV 225	return true;	×
226	}
227	}	×
228
229	if ((global->getLinkage() == GlobalValue::ExternalLinkage && global->isDeclaration())) {	17,843✔
230	LOG_DEBUG("Linkage: External");
231	return true;	1,260✔
232	}
233
234	Type* global_type = global->getValueType();	16,583✔
235	if (!global_type->isSized()) {	16,583✔
236	LOG_DEBUG("not sized");
237	return true;	×
238	}
239
240	if (global_type->isArrayTy()) {	16,583✔
241	global_type = global_type->getArrayElementType();	15,348✔
242	}	15,348✔
243	if (auto structType = dyn_cast<StructType>(global_type)) {	16,583✔
244	if (structType->isOpaque()) {	1,010✔
245	LOG_DEBUG("Encountered opaque struct " << global_type->getStructName() << " - skipping...");
246	return true;	×
247	}
248	}	1,010✔
249	return false;	16,583✔
250	}),	156,351✔
251	globals.end());	4,042✔
252
253	const auto beforeCallFilter = globals.size();	4,042✔
254	NumFilteredGlobals = NumDetectedGlobals - beforeCallFilter;	4,042✔
255
256	globals.erase(llvm::remove_if(globals, [&](const auto global) { return filter(global.global); }), globals.end());	20,625✔
257
258	NumCallFilteredGlobals = beforeCallFilter - globals.size();	4,042✔
259	NumFilteredGlobals += NumCallFilteredGlobals;	4,042✔
260	}	4,042✔
261
262	return llvm::count_if(module.functions(), [&](auto& function) { return runOnFunction(function); }) > 0;	129,503✔
263	} // namespace typeart	×
264
265	bool MemInstFinderPass::runOnFunction(llvm::Function& function) {	125,461✔
266	if (function.isDeclaration() \|\| util::starts_with_any_of(function.getName(), "__typeart")) {	125,461✔
267	return false;	100,532✔
268	}
269
270	LOG_DEBUG("Running on function: " << function.getName())
271
272	mOpsCollector.collect(function);	24,929✔
273
274	#if LLVM_VERSION_MAJOR < 15
275	const auto checkAmbigiousMalloc = [&function](const MallocData& mallocData) {
276	using namespace typeart::util::type;
277	auto primaryBitcast = mallocData.primary;
278	if (primaryBitcast != nullptr) {
279	const auto& bitcasts = mallocData.bitcasts;
280	std::for_each(bitcasts.begin(), bitcasts.end(), [&](auto bitcastInst) {
281	auto dest = bitcastInst->getDestTy();
282	if (bitcastInst != primaryBitcast &&
283	(!isVoidPtr(dest) && !isi64Ptr(dest) &&
284	primaryBitcast->getDestTy() != dest)) { // void* and i64* are used by LLVM
285	// Second non-void* bitcast detected - semantics unclear
286	LOG_WARNING("Encountered ambiguous pointer type in function: " << util::try_demangle(function));
287	LOG_WARNING(" Allocation" << util::dump(*(mallocData.call)));
288	LOG_WARNING(" Primary cast: " << util::dump(*primaryBitcast));
289	LOG_WARNING(" Secondary cast: " << util::dump(*bitcastInst));
290	}
291	});
292	}
293	};
294	#endif
295
296	NumDetectedAllocs += mOpsCollector.allocas.size();	24,929✔
297
298	if (config[config::ConfigStdArgs::analysis_filter_alloca_non_array]) {	24,929✔
299	auto& allocs = mOpsCollector.allocas;	480✔
300	allocs.erase(llvm::remove_if(allocs,	960✔
301	[&](const auto& data) {	1,365✔
302	if (!data.alloca->getAllocatedType()->isArrayTy() && data.array_size == 1) {	1,365✔
303	++NumFilteredNonArrayAllocs;	1,320✔
304	return true;	1,320✔
305	}
306	return false;	45✔
307	}),	1,365✔
308	allocs.end());	480✔
309	}	480✔
310
311	if (config[config::ConfigStdArgs::analysis_filter_heap_alloc]) {	24,929✔
312	auto& allocs = mOpsCollector.allocas;	15✔
313	auto& mallocs = mOpsCollector.mallocs;	15✔
314
315	const auto filterMallocAllocPairing = [&mallocs](const auto alloc) {	15✔
316	// Only look for the direct users of the alloc:
317	// TODO is a deeper analysis required?
UNCOV 318	for (auto inst : alloc->users()) {	×
UNCOV 319	if (StoreInst* store = dyn_cast<StoreInst>(inst)) {	×
UNCOV 320	const auto source = store->getValueOperand();	×
UNCOV 321	if (isa<BitCastInst>(source)) {	×
UNCOV 322	for (auto& mdata : mallocs) {	×
323	// is it a bitcast we already collected? if yes, we can filter the alloc
UNCOV 324	return std::any_of(mdata.bitcasts.begin(), mdata.bitcasts.end(),	×
UNCOV 325	[&source](const auto bcast) { return bcast == source; });	×
326	}
UNCOV 327	} else if (isa<CallInst>(source)) {	×
328	return std::any_of(mallocs.begin(), mallocs.end(),	×
329	[&source](const auto& mdata) { return mdata.call == source; });	×
330	}
UNCOV 331	}	×
332	}
UNCOV 333	return false;	×
UNCOV 334	};	×
335
336	allocs.erase(llvm::remove_if(allocs,	45✔
337	[&](const auto& data) {	15✔
UNCOV 338	if (filterMallocAllocPairing(data.alloca)) {	×
UNCOV 339	++NumFilteredMallocAllocs;	×
UNCOV 340	return true;	×
341	}
UNCOV 342	return false;	×
UNCOV 343	}),	×
344	allocs.end());	15✔
345	}	15✔
346
347	if (config[config::ConfigStdArgs::analysis_filter_pointer_alloc]) {	24,929✔
348	auto& allocs = mOpsCollector.allocas;	24,364✔
349	allocs.erase(llvm::remove_if(allocs,	48,728✔
350	[&](const auto& data) {	21,239✔
351	auto alloca = data.alloca;	21,239✔
352	if (!data.is_vla && isa<llvm::PointerType>(alloca->getAllocatedType())) {	21,239✔
353	++NumFilteredPointerAllocs;	9,025✔
354	return true;	9,025✔
355	}
356	return false;	12,214✔
357	}),	21,239✔
358	allocs.end());	24,364✔
359	}	24,364✔
360
361	// if (config.filter.useCallFilter) {
362	if (config[config::ConfigStdArgs::filter]) {	24,929✔
363	auto& allocs = mOpsCollector.allocas;	1,109✔
364	allocs.erase(llvm::remove_if(allocs,	3,327✔
365	[&](const auto& data) {	2,898✔
366	if (filter(data.alloca)) {	1,789✔
367	++NumCallFilteredAllocs;	1,473✔
368	return true;	1,473✔
369	}
370	return false;	316✔
371	}),	1,789✔
372	allocs.end());	1,109✔
373	// LOG_DEBUG(allocs.size() << " allocas to instrument : " << util::dump(allocs));
374	}	1,109✔
375
376	auto& mallocs = mOpsCollector.mallocs;	24,929✔
377	NumDetectedHeap += mallocs.size();	24,929✔
378
379	#if LLVM_VERSION_MAJOR < 15
380	for (const auto& mallocData : mallocs) {
381	checkAmbigiousMalloc(mallocData);
382	}
383	#endif
384
385	FunctionData data{mOpsCollector.mallocs, mOpsCollector.frees, mOpsCollector.allocas};	24,929✔
386	functionMap[&function] = data;	24,929✔
387
388	mOpsCollector.clear();	24,929✔
389
390	return true;	24,929✔
391	} // namespace typeart	125,461✔
392
393	void MemInstFinderPass::printStats(llvm::raw_ostream& out) const {	3,997✔
394	#if LLVM_VERSION_MAJOR < 22
395	const auto scope_exit_cleanup_counter = llvm::make_scope_exit([&]() {	6,400✔
396	#else
397	llvm::scope_exit scope_exit_cleanup_counter([&]() {	1,594✔
398	#endif
399	NumDetectedAllocs = 0;	3,997✔
400	NumFilteredNonArrayAllocs = 0;	3,997✔
401	NumFilteredMallocAllocs = 0;	3,997✔
402	NumCallFilteredAllocs = 0;	3,997✔
403	NumFilteredPointerAllocs = 0;	3,997✔
404	NumDetectedHeap = 0;	3,997✔
405	NumFilteredGlobals = 0;	3,997✔
406	NumDetectedGlobals = 0;	3,997✔
407	});	3,997✔
408	auto all_stack = double(NumDetectedAllocs);	3,997✔
409	auto nonarray_stack = double(NumFilteredNonArrayAllocs);	3,997✔
410	auto malloc_alloc_stack = double(NumFilteredMallocAllocs);	3,997✔
411	auto call_filter_stack = double(NumCallFilteredAllocs);	3,997✔
412	auto filter_pointer_stack = double(NumFilteredPointerAllocs);	3,997✔
413
414	const auto call_filter_stack_p =	3,997✔
415	(call_filter_stack /	3,997✔
416	std::max<double>(1.0, all_stack - nonarray_stack - malloc_alloc_stack - filter_pointer_stack)) *	3,997✔
417	100.0;
418
419	const auto call_filter_heap_p =	3,997✔
420	(double(NumFilteredDetectedHeap) / std::max<double>(1.0, double(NumDetectedHeap))) * 100.0;	3,997✔
421
422	const auto call_filter_global_p =	3,997✔
423	(double(NumCallFilteredGlobals) / std::max(1.0, double(NumDetectedGlobals))) * 100.0;	3,997✔
424
425	const auto call_filter_global_nocallfilter_p =	3,997✔
426	(double(NumFilteredGlobals) / std::max(1.0, double(NumDetectedGlobals))) * 100.0;	3,997✔
427
428	Table stats("MemInstFinderPass");	3,997✔
429	stats.wrap_header_ = true;	3,997✔
430	stats.wrap_length_ = true;	3,997✔
431	std::string glob = config[config::ConfigStdArgs::filter_glob];	3,997✔
432	stats.put(Row::make("Filter string", glob));	3,997✔
433	stats.put(Row::make_row("> Heap Memory"));	3,997✔
434	stats.put(Row::make("Heap alloc", NumDetectedHeap.getValue()));	3,997✔
435	stats.put(Row::make("Heap call filtered %", call_filter_heap_p));	3,997✔
436	stats.put(Row::make_row("> Stack Memory"));	3,997✔
437	stats.put(Row::make("Alloca", all_stack));	3,997✔
438	stats.put(Row::make("Stack call filtered %", call_filter_stack_p));	3,997✔
439	stats.put(Row::make("Alloca of pointer discarded", filter_pointer_stack));	3,997✔
440	stats.put(Row::make_row("> Global Memory"));	3,997✔
441	stats.put(Row::make("Global", NumDetectedGlobals.getValue()));	3,997✔
442	stats.put(Row::make("Global filter total", NumFilteredGlobals.getValue()));	3,997✔
443	stats.put(Row::make("Global call filtered %", call_filter_global_p));	3,997✔
444	stats.put(Row::make("Global filtered %", call_filter_global_nocallfilter_p));	3,997✔
445
446	std::ostringstream stream;	3,997✔
447	stats.print(stream);	3,997✔
448	out << stream.str();	3,997✔
449	}	3,997✔
450
451	bool MemInstFinderPass::hasFunctionData(const Function& function) const {	24,917✔
452	auto iter = functionMap.find(&function);	24,917✔
453	return iter != functionMap.end();	24,917✔
454	}
455
456	const FunctionData& MemInstFinderPass::getFunctionData(const Function& function) const {	24,917✔
457	auto iter = functionMap.find(&function);	24,917✔
458	return iter->second;	24,917✔
459	}
460
461	const GlobalDataList& MemInstFinderPass::getModuleGlobals() const {	1,877✔
462	return mOpsCollector.globals;	1,877✔
463	}
464
465	std::unique_ptr<MemInstFinder> create_finder(const config::Configuration& config) {	4,042✔
466	LOG_DEBUG("Constructing MemInstFinder")
467	// const auto meminst_conf = config::helper::config_to_options(config);
468	return std::make_unique<MemInstFinderPass>(config);	4,042✔
469	}
470
471	} // namespace typeart::analysis

tudasc / TypeART / 25177145272

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous