4551387784

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/tudasc/TypeART/commit/<a class=hub.com/tudasc/TypeART/commit/79677f06d6826133dc5f147eaa3951a6e90322cd">79677f06d<a href="https://github.com/tudasc/TypeART/commit/79677f06d6826133dc5f147eaa3951a6e90322cd">">Merge </a><a class="double-link" href="https://github.com/tudasc/TypeART/commit/<a class="double-link" href="https://github.com/tudasc/TypeART/commit/2ed9496d3844e60afd41b9b892cf8789c34a291b">2ed9496d3</a>">2ed9496d3</a><a href="https://github.com/tudasc/TypeART/commit/79677f06d6826133dc5f147eaa3951a6e90322cd"> into bac2841c3">bac2841c3</a>

Pull Request Pull Request #140: Feat/acg

Run Details

275 of 374 new or added lines in 9 files covered. (73.53%)

3734 of 4184 relevant lines covered (89.24%)

251497.84 hits per line

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

95.24

/lib/passes/TypeARTPass.cpp

// TypeART library
//
// Copyright (c) 2017-2022 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 "TypeARTPass.h"

#include "Commandline.h"
#include "TypeARTConfiguration.h"
#include "analysis/MemInstFinder.h"
#include "instrumentation/MemOpArgCollector.h"
#include "instrumentation/MemOpInstrumentation.h"
#include "instrumentation/TypeARTFunctions.h"
#include "support/FileConfiguration.h"
#include "support/Logger.h"
#include "support/Table.h"
#include "typegen/TypeGenerator.h"

#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/Module.h"
#include "llvm/Pass.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"

#include <cassert>
#include <cstddef>
#include <sstream>
#include <string>
#include <utility>

namespace llvm {
class BasicBlock;
}  // namespace llvm

using namespace llvm;

static llvm::RegisterPass<typeart::pass::TypeArtPass> msp("typeart", "TypeArt type instrumentation sanitizer", false,
                                                          false);

extern llvm::cl::OptionCategory typeart_category;

static cl::opt<std::string> cl_typeart_configuration_file(
    "typeart-config", cl::init(""),
    cl::desc(
        "Location of the configuration file to configure the TypeART pass. Commandline arguments are prioritized."),
    cl::cat(typeart_category));

static cl::opt<bool> cl_typeart_configuration_file_dump("typeart-config-dump", cl::init(false), cl::Hidden,
                                                        cl::desc("Dump default config file content to std::out."),
                                                        cl::cat(typeart_category));

#define DEBUG_TYPE "typeart"

ALWAYS_ENABLED_STATISTIC(NumInstrumentedMallocs, "Number of instrumented mallocs");
ALWAYS_ENABLED_STATISTIC(NumInstrumentedFrees, "Number of instrumented frees");
ALWAYS_ENABLED_STATISTIC(NumInstrumentedAlloca, "Number of instrumented (stack) allocas");
ALWAYS_ENABLED_STATISTIC(NumInstrumentedGlobal, "Number of instrumented globals");

namespace typeart::pass {

llvm::Optional<std::string> get_configuration_file_path() {
  if (!cl_typeart_configuration_file.empty()) {
    LOG_DEBUG("Using cl::opt for config file " << cl_typeart_configuration_file.getValue());
    return cl_typeart_configuration_file.getValue();
  }
  const char* config_file = std::getenv("TYPEART_CONFIG_FILE");
  if (config_file != nullptr) {
    LOG_DEBUG("Using env var for types file " << config_file)
    return std::string{config_file};
  }
  LOG_INFO("No configuration file set.")
  return llvm::None;
}

// Used by LLVM pass manager to identify passes in memory
char TypeArtPass::ID = 0;

TypeArtPass::TypeArtPass() : llvm::ModulePass(ID) {
  EnableStatistics(false);
}

void TypeArtPass::getAnalysisUsage(llvm::AnalysisUsage& info) const {
}

bool TypeArtPass::doInitialization(Module& m) {
  if (cl_typeart_configuration_file_dump.getValue()) {
    auto config = config::make_typeart_configuration({"", config::TypeARTConfigInit::FileConfigurationMode::Empty});
    config->get()->emitTypeartFileConfiguration(llvm::outs());
    LOG_DEBUG("Emitted standard config. Exiting now.")
    std::exit(EXIT_SUCCESS);
  }

  auto config_file_path = get_configuration_file_path();

  if (!config_file_path) {
    pass_config = std::make_unique<config::cl::CommandLineOptions>();
  } else {
    auto typeart_config = config::make_typeart_configuration({config_file_path.getValue()});
    if (typeart_config) {
      {
        std::string typeart_conf_str;
        llvm::raw_string_ostream conf_out_stream{typeart_conf_str};
        typeart_config->get()->emitTypeartFileConfiguration(conf_out_stream);
        LOG_INFO("Emitting TypeART file content\n" << conf_out_stream.str())
      }
      pass_config = std::move(*typeart_config);
    } else {
      LOG_FATAL("Could not load TypeARTConfiguration.")
      std::exit(EXIT_FAILURE);
    }
  }
  meminst_finder = analysis::create_finder(*pass_config);

  const std::string types_file =
      pass_config->getValueOr(config::ConfigStdArgs::types, {config::ConfigStdArgValues::types});

  typeManager = make_typegen(types_file);

  LOG_DEBUG("Propagating type infos.");
  const auto [loaded, error] = typeManager->load();
  if (loaded) {
    LOG_DEBUG("Existing type configuration successfully loaded from " << types_file);
  } else {
    LOG_DEBUG("No valid existing type configuration found: " << types_file << ". Reason: " << error.message());
  }

  instrumentation_helper.setModule(m);

  auto arg_collector                   = std::make_unique<MemOpArgCollector>(typeManager.get(), instrumentation_helper);
  const bool instrument_stack_lifetime = (*pass_config)[config::ConfigStdArgs::stack_lifetime];
  auto mem_instrument =
      std::make_unique<MemOpInstrumentation>(functions, instrumentation_helper, instrument_stack_lifetime);
  instrumentation_context =
      std::make_unique<InstrumentationContext>(std::move(arg_collector), std::move(mem_instrument));

  return true;
}

bool TypeArtPass::runOnModule(Module& m) {
  meminst_finder->runOnModule(m);
  const bool instrument_global = (*pass_config)[config::ConfigStdArgs::global];
  bool instrumented_global{false};
  if (instrument_global) {
    declareInstrumentationFunctions(m);

    const auto& globalsList = meminst_finder->getModuleGlobals();
    if (!globalsList.empty()) {
      const auto global_count = instrumentation_context->handleGlobal(globalsList);
      NumInstrumentedGlobal += global_count;
      instrumented_global = global_count > 0;
    }
  }

  const auto instrumented_function = llvm::count_if(m.functions(), [&](auto& f) { return runOnFunc(f); }) > 0;
  return instrumented_function || instrumented_global;
}

bool TypeArtPass::runOnFunc(Function& f) {
  using namespace typeart;

  if (f.isDeclaration() || f.getName().startswith("__typeart")) {
    return false;
  }

  if (!meminst_finder->hasFunctionData(f)) {
    LOG_WARNING("No allocation data could be retrieved for function: " << f.getName());
    return false;
  }

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

  // FIXME this is required when "PassManagerBuilder::EP_OptimizerLast" is used as the function (constant) pointer are
  // nullpointer/invalidated
  declareInstrumentationFunctions(*f.getParent());

  bool mod{false};
  //  auto& c = f.getContext();
  DataLayout dl(f.getParent());

  llvm::SmallDenseMap<BasicBlock*, size_t> allocCounts;

  const auto& fData   = meminst_finder->getFunctionData(f);
  const auto& mallocs = fData.mallocs;
  const auto& allocas = fData.allocas;
  const auto& frees   = fData.frees;

  const bool instrument_heap  = (*pass_config)[config::ConfigStdArgs::heap];
  const bool instrument_stack = (*pass_config)[config::ConfigStdArgs::stack];

  if (instrument_heap) {
    // instrument collected calls of bb:
    const auto heap_count = instrumentation_context->handleHeap(mallocs);
    const auto free_count = instrumentation_context->handleFree(frees);

    NumInstrumentedMallocs += heap_count;
    NumInstrumentedFrees += free_count;

    mod |= heap_count > 0 || free_count > 0;
  }

  if (instrument_stack) {
    const auto stack_count = instrumentation_context->handleStack(allocas);
    NumInstrumentedAlloca += stack_count;
    mod |= stack_count > 0;
  }

  return mod;
}  // namespace pass

bool TypeArtPass::doFinalization(Module&) {
  /*
   * Persist the accumulated type definition information for this module.
   */
  const std::string types_file = (*pass_config)[config::ConfigStdArgs::types];
  LOG_DEBUG("Writing type file to " << types_file);

  const auto [stored, error] = typeManager->store();
  if (stored) {
    LOG_DEBUG("Success!");
  } else {
    LOG_FATAL("Failed writing type config to " << types_file << ". Reason: " << error.message());
  }

  const bool print_stats = (*pass_config)[config::ConfigStdArgs::stats];
  if (print_stats) {
    auto& out = llvm::errs();
    printStats(out);
  }
  return false;
}

void TypeArtPass::declareInstrumentationFunctions(Module& m) {
  // Remove this return if problems come up during compilation
  if (typeart_alloc_global.f != nullptr && typeart_alloc_stack.f != nullptr && typeart_alloc.f != nullptr &&
      typeart_free.f != nullptr && typeart_leave_scope.f != nullptr) {
    return;
  }

  TAFunctionDeclarator decl(m, instrumentation_helper, functions);

  auto alloc_arg_types      = instrumentation_helper.make_parameters(IType::ptr, IType::type_id, IType::extent);
  auto free_arg_types       = instrumentation_helper.make_parameters(IType::ptr);
  auto leavescope_arg_types = instrumentation_helper.make_parameters(IType::stack_count);

  typeart_alloc.f        = decl.make_function(IFunc::heap, typeart_alloc.name, alloc_arg_types);
  typeart_alloc_stack.f  = decl.make_function(IFunc::stack, typeart_alloc_stack.name, alloc_arg_types);
  typeart_alloc_global.f = decl.make_function(IFunc::global, typeart_alloc_global.name, alloc_arg_types);
  typeart_free.f         = decl.make_function(IFunc::free, typeart_free.name, free_arg_types);
  typeart_leave_scope.f  = decl.make_function(IFunc::scope, typeart_leave_scope.name, leavescope_arg_types);

  typeart_alloc_omp.f = decl.make_function(IFunc::heap_omp, typeart_alloc_omp.name, alloc_arg_types, true);
  typeart_alloc_stacks_omp.f =
      decl.make_function(IFunc::stack_omp, typeart_alloc_stacks_omp.name, alloc_arg_types, true);
  typeart_free_omp.f = decl.make_function(IFunc::free_omp, typeart_free_omp.name, free_arg_types, true);
  typeart_leave_scope_omp.f =
      decl.make_function(IFunc::scope_omp, typeart_leave_scope_omp.name, leavescope_arg_types, true);
}

void TypeArtPass::printStats(llvm::raw_ostream& out) {
  meminst_finder->printStats(out);

  const auto get_ta_mode = [&]() {
    const bool heap  = (*pass_config)[config::ConfigStdArgs::heap];
    const bool stack = (*pass_config)[config::ConfigStdArgs::stack];

    if (heap) {
      if (stack) {
        return " [Heap & Stack]";
      }
      return " [Heap]";
    }

    if (stack) {
      return " [Stack]";
    }

    return " [Nop mode]";
    // happens when both heap and stack phases are disabled
    // llvm_unreachable("Did not find heap or stack, or combination thereof!");
  };

  Table stats("TypeArtPass");
  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()));
  stats.put(Row::make("Global", NumInstrumentedGlobal.getValue()));

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

}  // namespace typeart::pass

#include "llvm/IR/LegacyPassManager.h"
#include "llvm/Transforms/IPO/PassManagerBuilder.h"

static void registerClangPass(const llvm::PassManagerBuilder&, llvm::legacy::PassManagerBase& PM) {
  PM.add(new typeart::pass::TypeArtPass());
}
static RegisterStandardPasses RegisterClangPass(PassManagerBuilder::EP_OptimizerLast, registerClangPass);

1	// TypeART library
2	//
3	// Copyright (c) 2017-2022 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 "TypeARTPass.h"
14
15	#include "Commandline.h"
16	#include "TypeARTConfiguration.h"
17	#include "analysis/MemInstFinder.h"
18	#include "instrumentation/MemOpArgCollector.h"
19	#include "instrumentation/MemOpInstrumentation.h"
20	#include "instrumentation/TypeARTFunctions.h"
21	#include "support/FileConfiguration.h"
22	#include "support/Logger.h"
23	#include "support/Table.h"
24	#include "typegen/TypeGenerator.h"
25
26	#include "llvm/ADT/DenseMap.h"
27	#include "llvm/ADT/STLExtras.h"
28	#include "llvm/ADT/SmallVector.h"
29	#include "llvm/ADT/Statistic.h"
30	#include "llvm/ADT/StringRef.h"
31	#include "llvm/IR/DataLayout.h"
32	#include "llvm/IR/Function.h"
33	#include "llvm/IR/Module.h"
34	#include "llvm/Pass.h"
35	#include "llvm/Support/CommandLine.h"
36	#include "llvm/Support/raw_ostream.h"
37
38	#include <cassert>
39	#include <cstddef>
40	#include <sstream>
41	#include <string>
42	#include <utility>
43
44	namespace llvm {
45	class BasicBlock;
46	} // namespace llvm
47
48	using namespace llvm;
49
50	static llvm::RegisterPass<typeart::pass::TypeArtPass> msp("typeart", "TypeArt type instrumentation sanitizer", false,	2,586✔
51	false);	2,586✔
52
53	extern llvm::cl::OptionCategory typeart_category;
54
55	static cl::opt<std::string> cl_typeart_configuration_file(	5,172✔
56	"typeart-config", cl::init(""),	5,172✔
57	cl::desc(	5,172✔
58	"Location of the configuration file to configure the TypeART pass. Commandline arguments are prioritized."),	5,172✔
59	cl::cat(typeart_category));	7,758✔
60
61	static cl::opt<bool> cl_typeart_configuration_file_dump("typeart-config-dump", cl::init(false), cl::Hidden,	6,034✔
62	cl::desc("Dump default config file content to std::out."),	5,172✔
63	cl::cat(typeart_category));	7,758✔
64		2,586✔
65	#define DEBUG_TYPE "typeart"
66
67	ALWAYS_ENABLED_STATISTIC(NumInstrumentedMallocs, "Number of instrumented mallocs");	2,586✔
68	ALWAYS_ENABLED_STATISTIC(NumInstrumentedFrees, "Number of instrumented frees");	2,586✔
69	ALWAYS_ENABLED_STATISTIC(NumInstrumentedAlloca, "Number of instrumented (stack) allocas");	2,586✔
70	ALWAYS_ENABLED_STATISTIC(NumInstrumentedGlobal, "Number of instrumented globals");	2,586✔
71
72	namespace typeart::pass {
73
74	llvm::Optional<std::string> get_configuration_file_path() {	2,577✔
75	if (!cl_typeart_configuration_file.empty()) {	2,577✔
76	LOG_DEBUG("Using cl::opt for config file " << cl_typeart_configuration_file.getValue());
77	return cl_typeart_configuration_file.getValue();	54✔
78	}
79	const char* config_file = std::getenv("TYPEART_CONFIG_FILE");	2,523✔
80	if (config_file != nullptr) {	2,523✔
81	LOG_DEBUG("Using env var for types file " << config_file)
82	return std::string{config_file};	×
83	}
84	LOG_INFO("No configuration file set.")	2,523✔
85	return llvm::None;	2,523✔
86	}	2,577✔
87
88	// Used by LLVM pass manager to identify passes in memory
89	char TypeArtPass::ID = 0;
90
91	TypeArtPass::TypeArtPass() : llvm::ModulePass(ID) {	3,448✔
92	EnableStatistics(false);	2,586✔
93	}	2,586✔
94
95	void TypeArtPass::getAnalysisUsage(llvm::AnalysisUsage& info) const {	2,586✔
96	}	2,586✔
97
98	bool TypeArtPass::doInitialization(Module& m) {	2,583✔
99	if (cl_typeart_configuration_file_dump.getValue()) {	2,583✔
100	auto config = config::make_typeart_configuration({"", config::TypeARTConfigInit::FileConfigurationMode::Empty});	9✔
101	config->get()->emitTypeartFileConfiguration(llvm::outs());	9✔
102	LOG_DEBUG("Emitted standard config. Exiting now.")
103	std::exit(EXIT_SUCCESS);	9✔
104	}
105
106	auto config_file_path = get_configuration_file_path();	2,574✔
107
108	if (!config_file_path) {	2,574✔
109	pass_config = std::make_unique<config::cl::CommandLineOptions>();	2,520✔
110	} else {	2,520✔
111	auto typeart_config = config::make_typeart_configuration({config_file_path.getValue()});	54✔
112	if (typeart_config) {	54✔
113	{
114	std::string typeart_conf_str;	45✔
115	llvm::raw_string_ostream conf_out_stream{typeart_conf_str};	45✔
116	typeart_config->get()->emitTypeartFileConfiguration(conf_out_stream);	45✔
117	LOG_INFO("Emitting TypeART file content\n" << conf_out_stream.str())	45✔
118	}	45✔
119	pass_config = std::move(*typeart_config);	45✔
120	} else {	45✔
121	LOG_FATAL("Could not load TypeARTConfiguration.")	9✔
122	std::exit(EXIT_FAILURE);	9✔
123	}
124	}	45✔
125	meminst_finder = analysis::create_finder(*pass_config);	2,565✔
126
127	const std::string types_file =
128	pass_config->getValueOr(config::ConfigStdArgs::types, {config::ConfigStdArgValues::types});	2,565✔
129
130	typeManager = make_typegen(types_file);	2,565✔
131
132	LOG_DEBUG("Propagating type infos.");
133	const auto [loaded, error] = typeManager->load();	2,565✔
134	if (loaded) {	2,565✔
135	LOG_DEBUG("Existing type configuration successfully loaded from " << types_file);
136	} else {	1,869✔
137	LOG_DEBUG("No valid existing type configuration found: " << types_file << ". Reason: " << error.message());
138	}
139
140	instrumentation_helper.setModule(m);	2,565✔
141
142	auto arg_collector = std::make_unique<MemOpArgCollector>(typeManager.get(), instrumentation_helper);	2,565✔
143	const bool instrument_stack_lifetime = (*pass_config)[config::ConfigStdArgs::stack_lifetime];	2,565✔
144	auto mem_instrument =
145	std::make_unique<MemOpInstrumentation>(functions, instrumentation_helper, instrument_stack_lifetime);	2,565✔
146	instrumentation_context =	2,565✔
147	std::make_unique<InstrumentationContext>(std::move(arg_collector), std::move(mem_instrument));	2,565✔
148
149	return true;
150	}	2,565✔
151
152	bool TypeArtPass::runOnModule(Module& m) {	2,565✔
153	meminst_finder->runOnModule(m);	2,565✔
154	const bool instrument_global = (*pass_config)[config::ConfigStdArgs::global];	2,565✔
155	bool instrumented_global{false};	2,565✔
156	if (instrument_global) {	2,565✔
157	declareInstrumentationFunctions(m);	1,392✔
158
159	const auto& globalsList = meminst_finder->getModuleGlobals();	1,392✔
160	if (!globalsList.empty()) {	1,392✔
161	const auto global_count = instrumentation_context->handleGlobal(globalsList);	549✔
162	NumInstrumentedGlobal += global_count;	549✔
163	instrumented_global = global_count > 0;	549✔
164	}	549✔
165	}	1,392✔
166
167	const auto instrumented_function = llvm::count_if(m.functions(), [&](auto& f) { return runOnFunc(f); }) > 0;	68,697✔
168	return instrumented_function \|\| instrumented_global;	2,565✔
169	}
170
171	bool TypeArtPass::runOnFunc(Function& f) {	66,132✔
172	using namespace typeart;
173
174	if (f.isDeclaration() \|\| f.getName().startswith("__typeart")) {	66,132✔
175	return false;	42,087✔
176	}
177
178	if (!meminst_finder->hasFunctionData(f)) {	24,045✔
179	LOG_WARNING("No allocation data could be retrieved for function: " << f.getName());	×
180	return false;	×
181	}
182
183	LOG_DEBUG("Running on function: " << f.getName())
184
185	// FIXME this is required when "PassManagerBuilder::EP_OptimizerLast" is used as the function (constant) pointer are
186	// nullpointer/invalidated
187	declareInstrumentationFunctions(*f.getParent());	24,045✔
188
189	bool mod{false};	24,045✔
190	// auto& c = f.getContext();
191	DataLayout dl(f.getParent());	24,045✔
192
193	llvm::SmallDenseMap<BasicBlock*, size_t> allocCounts;	24,045✔
194
195	const auto& fData = meminst_finder->getFunctionData(f);	24,045✔
196	const auto& mallocs = fData.mallocs;	24,045✔
197	const auto& allocas = fData.allocas;	24,045✔
198	const auto& frees = fData.frees;	24,045✔
199
200	const bool instrument_heap = (*pass_config)[config::ConfigStdArgs::heap];	24,045✔
201	const bool instrument_stack = (*pass_config)[config::ConfigStdArgs::stack];	24,045✔
202
203	if (instrument_heap) {	24,045✔
204	// instrument collected calls of bb:
205	const auto heap_count = instrumentation_context->handleHeap(mallocs);	13,266✔
206	const auto free_count = instrumentation_context->handleFree(frees);	13,266✔
207
208	NumInstrumentedMallocs += heap_count;	13,266✔
209	NumInstrumentedFrees += free_count;	13,266✔
210
211	mod \|= heap_count > 0 \|\| free_count > 0;	13,266✔
212	}	13,266✔
213
214	if (instrument_stack) {	24,045✔
215	const auto stack_count = instrumentation_context->handleStack(allocas);	12,612✔
216	NumInstrumentedAlloca += stack_count;	12,612✔
217	mod \|= stack_count > 0;	12,612✔
218	}	12,612✔
219
220	return mod;	24,045✔
221	} // namespace pass	66,132✔
222
223	bool TypeArtPass::doFinalization(Module&) {	2,565✔
224	/*
225	* Persist the accumulated type definition information for this module.
226	*/
227	const std::string types_file = (*pass_config)[config::ConfigStdArgs::types];	2,565✔
228	LOG_DEBUG("Writing type file to " << types_file);
229
230	const auto [stored, error] = typeManager->store();	2,565✔
231	if (stored) {	2,565✔
232	LOG_DEBUG("Success!");
233	} else {	2,559✔
234	LOG_FATAL("Failed writing type config to " << types_file << ". Reason: " << error.message());	×
235	}
236
237	const bool print_stats = (*pass_config)[config::ConfigStdArgs::stats];	2,559✔
238	if (print_stats) {	2,559✔
239	auto& out = llvm::errs();	2,559✔
240	printStats(out);	2,559✔
241	}	2,559✔
242	return false;
243	}	2,559✔
244
245	void TypeArtPass::declareInstrumentationFunctions(Module& m) {	25,437✔
246	// Remove this return if problems come up during compilation
247	if (typeart_alloc_global.f != nullptr && typeart_alloc_stack.f != nullptr && typeart_alloc.f != nullptr &&	48,309✔
248	typeart_free.f != nullptr && typeart_leave_scope.f != nullptr) {	22,872✔
249	return;	22,872✔
250	}
251
252	TAFunctionDeclarator decl(m, instrumentation_helper, functions);	2,565✔
253
254	auto alloc_arg_types = instrumentation_helper.make_parameters(IType::ptr, IType::type_id, IType::extent);	2,565✔
255	auto free_arg_types = instrumentation_helper.make_parameters(IType::ptr);	2,565✔
256	auto leavescope_arg_types = instrumentation_helper.make_parameters(IType::stack_count);	2,565✔
257
258	typeart_alloc.f = decl.make_function(IFunc::heap, typeart_alloc.name, alloc_arg_types);	2,565✔
259	typeart_alloc_stack.f = decl.make_function(IFunc::stack, typeart_alloc_stack.name, alloc_arg_types);	2,565✔
260	typeart_alloc_global.f = decl.make_function(IFunc::global, typeart_alloc_global.name, alloc_arg_types);	2,565✔
261	typeart_free.f = decl.make_function(IFunc::free, typeart_free.name, free_arg_types);	2,565✔
262	typeart_leave_scope.f = decl.make_function(IFunc::scope, typeart_leave_scope.name, leavescope_arg_types);	2,565✔
263
264	typeart_alloc_omp.f = decl.make_function(IFunc::heap_omp, typeart_alloc_omp.name, alloc_arg_types, true);	2,565✔
265	typeart_alloc_stacks_omp.f =	2,565✔
266	decl.make_function(IFunc::stack_omp, typeart_alloc_stacks_omp.name, alloc_arg_types, true);	2,565✔
267	typeart_free_omp.f = decl.make_function(IFunc::free_omp, typeart_free_omp.name, free_arg_types, true);	2,565✔
268	typeart_leave_scope_omp.f =	2,565✔
269	decl.make_function(IFunc::scope_omp, typeart_leave_scope_omp.name, leavescope_arg_types, true);	2,565✔
270	}	25,437✔
271
272	void TypeArtPass::printStats(llvm::raw_ostream& out) {	2,559✔
273	meminst_finder->printStats(out);	2,559✔
274
275	const auto get_ta_mode = [&]() {	5,118✔
276	const bool heap = (*pass_config)[config::ConfigStdArgs::heap];	2,559✔
277	const bool stack = (*pass_config)[config::ConfigStdArgs::stack];	2,559✔
278
279	if (heap) {	2,559✔
280	if (stack) {	1,797✔
281	return " [Heap & Stack]";	618✔
282	}
283	return " [Heap]";	1,179✔
284	}
285
286	if (stack) {	762✔
287	return " [Stack]";	762✔
288	}
289
NEW 290	return " [Nop mode]";	×
291	// happens when both heap and stack phases are disabled
292	// llvm_unreachable("Did not find heap or stack, or combination thereof!");
293	};	2,559✔
294
295	Table stats("TypeArtPass");	2,559✔
296	stats.wrap_header = true;	2,559✔
297	stats.title += get_ta_mode();	2,559✔
298	stats.put(Row::make("Malloc", NumInstrumentedMallocs.getValue()));	2,559✔
299	stats.put(Row::make("Free", NumInstrumentedFrees.getValue()));	2,559✔
300	stats.put(Row::make("Alloca", NumInstrumentedAlloca.getValue()));	2,559✔
301	stats.put(Row::make("Global", NumInstrumentedGlobal.getValue()));	2,559✔
302
303	std::ostringstream stream;	2,559✔
304	stats.print(stream);	2,559✔
305	out << stream.str();	2,559✔
306	}	2,559✔
307
308	} // namespace typeart::pass
309
310	#include "llvm/IR/LegacyPassManager.h"
311	#include "llvm/Transforms/IPO/PassManagerBuilder.h"
312
313	static void registerClangPass(const llvm::PassManagerBuilder&, llvm::legacy::PassManagerBase& PM) {	×
314	PM.add(new typeart::pass::TypeArtPass());	×
315	}	×
316	static RegisterStandardPasses RegisterClangPass(PassManagerBuilder::EP_OptimizerLast, registerClangPass);	2,586✔

tudasc / TypeART / 4551387784

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