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

92.68

/lib/passes/configuration/TypeARTOptions.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 "TypeARTOptions.h"

#include "Configuration.h"
#include "FileConfiguration.h"
#include "instrumentation/TypeIDProvider.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::TypeSerializationImplementation> {
  static void enumeration(IO& io, typeart::TypeSerializationImplementation& value) {
    io.enumCase(value, "inline", typeart::TypeSerializationImplementation::INLINE);
    io.enumCase(value, "file", typeart::TypeSerializationImplementation::FILE);
    io.enumCase(value, "hybrid", typeart::TypeSerializationImplementation::HYBRID);
  }
};

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.mapOptional(ConfigStdArgs::gpu, info.gpu);
    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::type_serialization, info.type_serialization);
    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::gpu, config.gpu);
  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);
  make_entry(ConfigStdArgs::type_serialization, config.type_serialization);
  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::gpu, config.gpu),
      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),
      make_entry(ConfigStdArgs::type_serialization, config.type_serialization),
  };
  return mapping_;
}  // namespace helper

}  // namespace helper

}  // namespace typeart::config

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

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