13955121336

Committed 19 Mar 2025 07:30PM UTC coverage: 88.842%. First build

Build # 13955121336

Build Type

push

github

Committed by

web-flow

Commit Message

Merge PR #167 from tudasc/devel

Run Details

1174 of 1361 new or added lines in 49 files covered. (86.26%)

4212 of 4741 relevant lines covered (88.84%)

261950.04 hits per line

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

91.96

/lib/passes/configuration/TypeARTOptions.cpp

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

#include "Configuration.h"
#include "FileConfiguration.h"

#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/YAMLTraits.h"

using namespace llvm::yaml;
using namespace typeart::config::file;

template <>
struct llvm::yaml::ScalarEnumerationTraits<typeart::analysis::FilterImplementation> {
  static void enumeration(IO& io, typeart::analysis::FilterImplementation& value) {
    io.enumCase(value, "cg", typeart::analysis::FilterImplementation::cg);
    io.enumCase(value, "std", typeart::analysis::FilterImplementation::standard);
    io.enumCase(value, "none", typeart::analysis::FilterImplementation::none);
  }
};

template <>
struct llvm::yaml::ScalarEnumerationTraits<typeart::TypegenImplementation> {
  static void enumeration(IO& io, typeart::TypegenImplementation& value) {
    io.enumCase(value, "dimeta", typeart::TypegenImplementation::DIMETA);
    io.enumCase(value, "ir", typeart::TypegenImplementation::IR);
  }
};

template <>
struct llvm::yaml::MappingTraits<typeart::config::TypeARTAnalysisOptions> {
  static void mapping(IO& yml_io, typeart::config::TypeARTAnalysisOptions& info) {
    using typeart::config::ConfigStdArgs;
    const auto drop_prefix = [](const std::string& path, std::string_view prefix = "analysis-") {
      llvm::StringRef prefix_less{path};
      prefix_less.consume_front(prefix.data());
      return prefix_less;
    };
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_global).data(), info.filter_global);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_heap_alloc).data(), info.filter_heap_alloc);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_pointer_alloc).data(), info.filter_pointer_alloc);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_alloca_non_array).data(),
                       info.filter_alloca_non_array);
  }
};

template <>
struct llvm::yaml::MappingTraits<typeart::config::TypeARTCallFilterOptions> {
  static void mapping(IO& yml_io, typeart::config::TypeARTCallFilterOptions& info) {
    using typeart::config::ConfigStdArgs;
    const auto drop_prefix = [](const std::string& path, std::string_view prefix = "filter-") {
      llvm::StringRef prefix_less{path};
      prefix_less.consume_front(prefix.data());
      return prefix_less;
    };
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_impl).data(), info.implementation);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob).data(), info.glob);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob_deep).data(), info.glob_deep);
    yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_cg_file).data(), info.cg_file);
  }
};

template <>
struct llvm::yaml::MappingTraits<typeart::config::TypeARTConfigOptions> {
  static void mapping(IO& yml_io, typeart::config::TypeARTConfigOptions& info) {
    using typeart::config::ConfigStdArgs;
    yml_io.mapRequired(ConfigStdArgs::types, info.types);
    yml_io.mapRequired(ConfigStdArgs::heap, info.heap);
    yml_io.mapRequired(ConfigStdArgs::stack, info.stack);
    yml_io.mapOptional(ConfigStdArgs::global, info.global);
    yml_io.mapOptional(ConfigStdArgs::stats, info.statistics);
    yml_io.mapOptional(ConfigStdArgs::stack_lifetime, info.stack_lifetime);
    yml_io.mapRequired(ConfigStdArgs::typegen, info.typegen);
    yml_io.mapRequired(ConfigStdArgs::filter, info.filter);
    yml_io.mapOptional("call-filter", info.filter_config);
    yml_io.mapOptional("analysis", info.analysis_config);
    // yml_io.mapOptional("file-format", info.version);
  }
};

namespace typeart::config::io::yaml {

TypeARTConfigOptions yaml_read_file(llvm::yaml::Input& input) {
  TypeARTConfigOptions file_content{};
  input >> file_content;

  return file_content;
}

void yaml_output_file(llvm::yaml::Output& output, const TypeARTConfigOptions& config) {
  output << const_cast<TypeARTConfigOptions&>(config);
}

}  // namespace typeart::config::io::yaml

namespace typeart::config {

llvm::raw_ostream& operator<<(llvm::raw_ostream& out_stream, const TypeARTConfigOptions& options) {
  std::string config_text;
  llvm::raw_string_ostream sstream(config_text);
  llvm::yaml::Output out(sstream);
  io::yaml::yaml_output_file(out, options);
  out_stream.flush();
  out_stream << sstream.str();
  return out_stream;
}

namespace helper {

template <typename Constructor>
TypeARTConfigOptions construct_with(Constructor&& make_entry) {
  TypeARTConfigOptions config;
  make_entry(ConfigStdArgs::types, config.types);
  make_entry(ConfigStdArgs::stats, config.statistics);
  make_entry(ConfigStdArgs::heap, config.heap);
  make_entry(ConfigStdArgs::global, config.global);
  make_entry(ConfigStdArgs::stack, config.stack);
  make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime);
  make_entry(ConfigStdArgs::filter, config.filter);
  make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation);
  make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob);
  make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep);
  make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file);
  make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global);
  make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc);
  make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc);
  make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array);
  make_entry(ConfigStdArgs::typegen, config.typegen);
  return config;
}

TypeARTConfigOptions map_to_options(const OptionsMap& mapping) {
  const auto make_entry = [&](std::string_view entry, auto& ref) {
    auto key = llvm::StringRef(entry.data());
    ref      = static_cast<typename std::remove_reference<decltype(ref)>::type>(mapping.lookup(key));
  };
  return construct_with(make_entry);
}

TypeARTConfigOptions config_to_options(const Configuration& configuration) {
  const auto make_entry = [&](std::string_view entry, auto& ref) {
    auto key = llvm::StringRef(entry.data());
    ref      = static_cast<typename std::remove_reference<decltype(ref)>::type>(configuration[key]);
  };
  return construct_with(make_entry);
}

template <typename T>
auto make_entry(std::string_view key, const T& field_value)
    -> std::pair<llvm::StringRef, typename OptionsMap::mapped_type> {
  if constexpr (std::is_enum_v<T>) {
    return {key, config::OptionValue{static_cast<int>(field_value)}};
  } else {
    return {key, config::OptionValue{field_value}};
  }
};

OptionsMap options_to_map(const TypeARTConfigOptions& config) {
  OptionsMap mapping_ = {
      make_entry(ConfigStdArgs::types, config.types),
      make_entry(ConfigStdArgs::stats, config.statistics),
      make_entry(ConfigStdArgs::heap, config.heap),
      make_entry(ConfigStdArgs::global, config.global),
      make_entry(ConfigStdArgs::stack, config.stack),
      make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime),
      make_entry(ConfigStdArgs::typegen, config.typegen),
      make_entry(ConfigStdArgs::filter, config.filter),
      make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation),
      make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob),
      make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep),
      make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file),
      make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global),
      make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc),
      make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc),
      make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array),
  };
  return mapping_;
}

}  // namespace helper

}  // namespace typeart::config

1	// TypeART library
2	//
3	// Copyright (c) 2017-2025 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 "TypeARTOptions.h"
14
15	#include "Configuration.h"
16	#include "FileConfiguration.h"
17
18	#include "llvm/ADT/StringMap.h"
19	#include "llvm/ADT/StringRef.h"
20	#include "llvm/Support/FileSystem.h"
21	#include "llvm/Support/MemoryBuffer.h"
22	#include "llvm/Support/YAMLTraits.h"
23
24	using namespace llvm::yaml;
25	using namespace typeart::config::file;
26
27	template <>
28	struct llvm::yaml::ScalarEnumerationTraits<typeart::analysis::FilterImplementation> {
29	static void enumeration(IO& io, typeart::analysis::FilterImplementation& value) {	3,118✔
30	io.enumCase(value, "cg", typeart::analysis::FilterImplementation::cg);	3,118✔
31	io.enumCase(value, "std", typeart::analysis::FilterImplementation::standard);	3,118✔
32	io.enumCase(value, "none", typeart::analysis::FilterImplementation::none);	3,118✔
33	}	3,118✔
34	};
35
36	template <>
37	struct llvm::yaml::ScalarEnumerationTraits<typeart::TypegenImplementation> {
38	static void enumeration(IO& io, typeart::TypegenImplementation& value) {	3,118✔
39	io.enumCase(value, "dimeta", typeart::TypegenImplementation::DIMETA);	3,118✔
40	io.enumCase(value, "ir", typeart::TypegenImplementation::IR);	3,118✔
41	}	3,118✔
42	};
43
44	template <>
45	struct llvm::yaml::MappingTraits<typeart::config::TypeARTAnalysisOptions> {
46	static void mapping(IO& yml_io, typeart::config::TypeARTAnalysisOptions& info) {	3,118✔
47	using typeart::config::ConfigStdArgs;
48	const auto drop_prefix = [](const std::string& path, std::string_view prefix = "analysis-") {	12,472✔
49	llvm::StringRef prefix_less{path};	12,472✔
50	prefix_less.consume_front(prefix.data());	12,472✔
51	return prefix_less;	12,472✔
52	};
53	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_global).data(), info.filter_global);	3,118✔
54	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_heap_alloc).data(), info.filter_heap_alloc);	3,118✔
55	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_pointer_alloc).data(), info.filter_pointer_alloc);	3,118✔
56	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_alloca_non_array).data(),	3,118✔
57	info.filter_alloca_non_array);	3,118✔
58	}	3,118✔
59	};
60
61	template <>
62	struct llvm::yaml::MappingTraits<typeart::config::TypeARTCallFilterOptions> {
63	static void mapping(IO& yml_io, typeart::config::TypeARTCallFilterOptions& info) {	3,118✔
64	using typeart::config::ConfigStdArgs;
65	const auto drop_prefix = [](const std::string& path, std::string_view prefix = "filter-") {	12,472✔
66	llvm::StringRef prefix_less{path};	12,472✔
67	prefix_less.consume_front(prefix.data());	12,472✔
68	return prefix_less;	12,472✔
69	};
70	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_impl).data(), info.implementation);	3,118✔
71	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob).data(), info.glob);	3,118✔
72	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob_deep).data(), info.glob_deep);	3,118✔
73	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_cg_file).data(), info.cg_file);	3,118✔
74	}	3,118✔
75	};
76
77	template <>
78	struct llvm::yaml::MappingTraits<typeart::config::TypeARTConfigOptions> {
79	static void mapping(IO& yml_io, typeart::config::TypeARTConfigOptions& info) {	3,118✔
80	using typeart::config::ConfigStdArgs;
81	yml_io.mapRequired(ConfigStdArgs::types, info.types);	3,118✔
82	yml_io.mapRequired(ConfigStdArgs::heap, info.heap);	3,118✔
83	yml_io.mapRequired(ConfigStdArgs::stack, info.stack);	3,118✔
84	yml_io.mapOptional(ConfigStdArgs::global, info.global);	3,118✔
85	yml_io.mapOptional(ConfigStdArgs::stats, info.statistics);	3,118✔
86	yml_io.mapOptional(ConfigStdArgs::stack_lifetime, info.stack_lifetime);	3,118✔
87	yml_io.mapRequired(ConfigStdArgs::typegen, info.typegen);	3,118✔
88	yml_io.mapRequired(ConfigStdArgs::filter, info.filter);	3,118✔
89	yml_io.mapOptional("call-filter", info.filter_config);	3,118✔
90	yml_io.mapOptional("analysis", info.analysis_config);	3,118✔
91	// yml_io.mapOptional("file-format", info.version);
92	}	3,118✔
93	};
94
95	namespace typeart::config::io::yaml {
96
NEW 97	TypeARTConfigOptions yaml_read_file(llvm::yaml::Input& input) {	×
NEW 98	TypeARTConfigOptions file_content{};	×
99	input >> file_content;
100
101	return file_content;
102	}
103
104	void yaml_output_file(llvm::yaml::Output& output, const TypeARTConfigOptions& config) {	3,118✔
105	output << const_cast<TypeARTConfigOptions&>(config);	3,118✔
106	}	3,118✔
107
108	} // namespace typeart::config::io::yaml
109
110	namespace typeart::config {
111
112	llvm::raw_ostream& operator<<(llvm::raw_ostream& out_stream, const TypeARTConfigOptions& options) {	3,118✔
113	std::string config_text;	3,118✔
114	llvm::raw_string_ostream sstream(config_text);	3,118✔
115	llvm::yaml::Output out(sstream);	3,118✔
116	io::yaml::yaml_output_file(out, options);	3,118✔
117	out_stream.flush();	3,118✔
118	out_stream << sstream.str();	3,118✔
119	return out_stream;	3,118✔
120	}	3,118✔
121
122	namespace helper {
123
124	template <typename Constructor>
125	TypeARTConfigOptions construct_with(Constructor&& make_entry) {	3,118✔
126	TypeARTConfigOptions config;	3,118✔
127	make_entry(ConfigStdArgs::types, config.types);	3,118✔
128	make_entry(ConfigStdArgs::stats, config.statistics);	3,118✔
129	make_entry(ConfigStdArgs::heap, config.heap);	3,118✔
130	make_entry(ConfigStdArgs::global, config.global);	3,118✔
131	make_entry(ConfigStdArgs::stack, config.stack);	3,118✔
132	make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime);	3,118✔
133	make_entry(ConfigStdArgs::filter, config.filter);	3,118✔
134	make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation);	3,118✔
135	make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob);	3,118✔
136	make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep);	3,118✔
137	make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file);	3,118✔
138	make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global);	3,118✔
139	make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc);	3,118✔
140	make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc);	3,118✔
141	make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array);	3,118✔
142	make_entry(ConfigStdArgs::typegen, config.typegen);	3,118✔
143	return config;	3,118✔
144	}	3,118✔
145
NEW 146	TypeARTConfigOptions map_to_options(const OptionsMap& mapping) {	×
NEW 147	const auto make_entry = [&](std::string_view entry, auto& ref) {	×
NEW 148	auto key = llvm::StringRef(entry.data());	×
NEW 149	ref = static_cast<typename std::remove_reference<decltype(ref)>::type>(mapping.lookup(key));	×
NEW 150	};	×
NEW 151	return construct_with(make_entry);	×
152	}
153
154	TypeARTConfigOptions config_to_options(const Configuration& configuration) {	3,118✔
155	const auto make_entry = [&](std::string_view entry, auto& ref) {	53,006✔
156	auto key = llvm::StringRef(entry.data());	49,888✔
157	ref = static_cast<typename std::remove_reference<decltype(ref)>::type>(configuration[key]);	49,888✔
158	};	49,888✔
159	return construct_with(make_entry);	3,118✔
160	}
161
162	template <typename T>
163	auto make_entry(std::string_view key, const T& field_value)	149,856✔
164	-> std::pair<llvm::StringRef, typename OptionsMap::mapped_type> {
165	if constexpr (std::is_enum_v<T>) {
166	return {key, config::OptionValue{static_cast<int>(field_value)}};	18,732✔
167	} else {
168	return {key, config::OptionValue{field_value}};	131,124✔
169	}
NEW 170	};	×
171
172	OptionsMap options_to_map(const TypeARTConfigOptions& config) {	9,366✔
173	OptionsMap mapping_ = {	9,366✔
174	make_entry(ConfigStdArgs::types, config.types),	9,366✔
175	make_entry(ConfigStdArgs::stats, config.statistics),	9,366✔
176	make_entry(ConfigStdArgs::heap, config.heap),	9,366✔
177	make_entry(ConfigStdArgs::global, config.global),	9,366✔
178	make_entry(ConfigStdArgs::stack, config.stack),	9,366✔
179	make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime),	9,366✔
180	make_entry(ConfigStdArgs::typegen, config.typegen),	9,366✔
181	make_entry(ConfigStdArgs::filter, config.filter),	9,366✔
182	make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation),	9,366✔
183	make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob),	9,366✔
184	make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep),	9,366✔
185	make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file),	9,366✔
186	make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global),	9,366✔
187	make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc),	9,366✔
188	make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc),	9,366✔
189	make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array),	9,366✔
190	};
191	return mapping_;	9,366✔
192	}	9,366✔
193
194	} // namespace helper
195
196	} // namespace typeart::config

tudasc / TypeART / 13955121336

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