13528988609

Committed 25 Feb 2025 07:06PM UTC coverage: 88.854% (-1.9%) from 90.735%

Build # 13528988609

Build Type

Pull #163

github

Committed by

web-flow

Commit Message

Merge e4a2d80f6 into d2e14acc5

Pull Request Pull Request #163: LLVM 18 support

Run Details

974 of 1122 new or added lines in 38 files covered. (86.81%)

30 existing lines in 6 files now uncovered.

4201 of 4728 relevant lines covered (88.85%)

190054.62 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) {	2,350✔
30	io.enumCase(value, "cg", typeart::analysis::FilterImplementation::cg);	2,350✔
31	io.enumCase(value, "std", typeart::analysis::FilterImplementation::standard);	2,350✔
32	io.enumCase(value, "none", typeart::analysis::FilterImplementation::none);	2,350✔
33	}	2,350✔
34	};
35
36	template <>
37	struct llvm::yaml::ScalarEnumerationTraits<typeart::TypegenImplementation> {
38	static void enumeration(IO& io, typeart::TypegenImplementation& value) {	2,350✔
39	io.enumCase(value, "dimeta", typeart::TypegenImplementation::DIMETA);	2,350✔
40	io.enumCase(value, "ir", typeart::TypegenImplementation::IR);	2,350✔
41	}	2,350✔
42	};
43
44	template <>
45	struct llvm::yaml::MappingTraits<typeart::config::TypeARTAnalysisOptions> {
46	static void mapping(IO& yml_io, typeart::config::TypeARTAnalysisOptions& info) {	2,350✔
47	using typeart::config::ConfigStdArgs;
48	const auto drop_prefix = [](const std::string& path, std::string_view prefix = "analysis-") {	9,400✔
49	llvm::StringRef prefix_less{path};	9,400✔
50	prefix_less.consume_front(prefix.data());	9,400✔
51	return prefix_less;	9,400✔
52	};
53	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_global).data(), info.filter_global);	2,350✔
54	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_heap_alloc).data(), info.filter_heap_alloc);	2,350✔
55	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_pointer_alloc).data(), info.filter_pointer_alloc);	2,350✔
56	yml_io.mapOptional(drop_prefix(ConfigStdArgs::analysis_filter_alloca_non_array).data(),	2,350✔
57	info.filter_alloca_non_array);	2,350✔
58	}	2,350✔
59	};
60
61	template <>
62	struct llvm::yaml::MappingTraits<typeart::config::TypeARTCallFilterOptions> {
63	static void mapping(IO& yml_io, typeart::config::TypeARTCallFilterOptions& info) {	2,350✔
64	using typeart::config::ConfigStdArgs;
65	const auto drop_prefix = [](const std::string& path, std::string_view prefix = "filter-") {	9,400✔
66	llvm::StringRef prefix_less{path};	9,400✔
67	prefix_less.consume_front(prefix.data());	9,400✔
68	return prefix_less;	9,400✔
69	};
70	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_impl).data(), info.implementation);	2,350✔
71	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob).data(), info.glob);	2,350✔
72	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_glob_deep).data(), info.glob_deep);	2,350✔
73	yml_io.mapOptional(drop_prefix(ConfigStdArgs::filter_cg_file).data(), info.cg_file);	2,350✔
74	}	2,350✔
75	};
76
77	template <>
78	struct llvm::yaml::MappingTraits<typeart::config::TypeARTConfigOptions> {
79	static void mapping(IO& yml_io, typeart::config::TypeARTConfigOptions& info) {	2,350✔
80	using typeart::config::ConfigStdArgs;
81	yml_io.mapRequired(ConfigStdArgs::types, info.types);	2,350✔
82	yml_io.mapRequired(ConfigStdArgs::heap, info.heap);	2,350✔
83	yml_io.mapRequired(ConfigStdArgs::stack, info.stack);	2,350✔
84	yml_io.mapOptional(ConfigStdArgs::global, info.global);	2,350✔
85	yml_io.mapOptional(ConfigStdArgs::stats, info.statistics);	2,350✔
86	yml_io.mapOptional(ConfigStdArgs::stack_lifetime, info.stack_lifetime);	2,350✔
87	yml_io.mapRequired(ConfigStdArgs::typegen, info.typegen);	2,350✔
88	yml_io.mapRequired(ConfigStdArgs::filter, info.filter);	2,350✔
89	yml_io.mapOptional("call-filter", info.filter_config);	2,350✔
90	yml_io.mapOptional("analysis", info.analysis_config);	2,350✔
91	// yml_io.mapOptional("file-format", info.version);
92	}	2,350✔
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) {	2,350✔
105	output << const_cast<TypeARTConfigOptions&>(config);	2,350✔
106	}	2,350✔
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) {	2,350✔
113	std::string config_text;	2,350✔
114	llvm::raw_string_ostream sstream(config_text);	2,350✔
115	llvm::yaml::Output out(sstream);	2,350✔
116	io::yaml::yaml_output_file(out, options);	2,350✔
117	out_stream.flush();	2,350✔
118	out_stream << sstream.str();	2,350✔
119	return out_stream;	2,350✔
120	}	2,350✔
121
122	namespace helper {
123
124	template <typename Constructor>
125	TypeARTConfigOptions construct_with(Constructor&& make_entry) {	2,350✔
126	TypeARTConfigOptions config;	2,350✔
127	make_entry(ConfigStdArgs::types, config.types);	2,350✔
128	make_entry(ConfigStdArgs::stats, config.statistics);	2,350✔
129	make_entry(ConfigStdArgs::heap, config.heap);	2,350✔
130	make_entry(ConfigStdArgs::global, config.global);	2,350✔
131	make_entry(ConfigStdArgs::stack, config.stack);	2,350✔
132	make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime);	2,350✔
133	make_entry(ConfigStdArgs::filter, config.filter);	2,350✔
134	make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation);	2,350✔
135	make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob);	2,350✔
136	make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep);	2,350✔
137	make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file);	2,350✔
138	make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global);	2,350✔
139	make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc);	2,350✔
140	make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc);	2,350✔
141	make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array);	2,350✔
142	make_entry(ConfigStdArgs::typegen, config.typegen);	2,350✔
143	return config;	2,350✔
144	}	2,350✔
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) {	2,350✔
155	const auto make_entry = [&](std::string_view entry, auto& ref) {	39,950✔
156	auto key = llvm::StringRef(entry.data());	37,600✔
157	ref = static_cast<typename std::remove_reference<decltype(ref)>::type>(configuration[key]);	37,600✔
158	};	37,600✔
159	return construct_with(make_entry);	2,350✔
160	}
161
162	template <typename T>
163	auto make_entry(std::string_view key, const T& field_value)	112,944✔
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)}};	14,118✔
167	} else {
168	return {key, config::OptionValue{field_value}};	98,826✔
169	}
NEW 170	};	×
171
172	OptionsMap options_to_map(const TypeARTConfigOptions& config) {	7,059✔
173	OptionsMap mapping_ = {	7,059✔
174	make_entry(ConfigStdArgs::types, config.types),	7,059✔
175	make_entry(ConfigStdArgs::stats, config.statistics),	7,059✔
176	make_entry(ConfigStdArgs::heap, config.heap),	7,059✔
177	make_entry(ConfigStdArgs::global, config.global),	7,059✔
178	make_entry(ConfigStdArgs::stack, config.stack),	7,059✔
179	make_entry(ConfigStdArgs::stack_lifetime, config.stack_lifetime),	7,059✔
180	make_entry(ConfigStdArgs::typegen, config.typegen),	7,059✔
181	make_entry(ConfigStdArgs::filter, config.filter),	7,059✔
182	make_entry(ConfigStdArgs::filter_impl, config.filter_config.implementation),	7,059✔
183	make_entry(ConfigStdArgs::filter_glob, config.filter_config.glob),	7,059✔
184	make_entry(ConfigStdArgs::filter_glob_deep, config.filter_config.glob_deep),	7,059✔
185	make_entry(ConfigStdArgs::filter_cg_file, config.filter_config.cg_file),	7,059✔
186	make_entry(ConfigStdArgs::analysis_filter_global, config.analysis_config.filter_global),	7,059✔
187	make_entry(ConfigStdArgs::analysis_filter_heap_alloc, config.analysis_config.filter_heap_alloc),	7,059✔
188	make_entry(ConfigStdArgs::analysis_filter_pointer_alloc, config.analysis_config.filter_pointer_alloc),	7,059✔
189	make_entry(ConfigStdArgs::analysis_filter_alloca_non_array, config.analysis_config.filter_alloca_non_array),	7,059✔
190	};
191	return mapping_;	7,059✔
192	}	7,059✔
193
194	} // namespace helper
195
196	} // namespace typeart::config

tudasc / TypeART / 13528988609

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