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

83.7

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

#include "OptionsUtil.h"
#include "analysis/MemInstFinder.h"
#include "configuration/Configuration.h"
#include "instrumentation/TypeIDProvider.h"
#include "support/ConfigurationBase.h"
#include "support/ConfigurationBaseOptions.h"
#include "support/Error.h"
#include "support/Logger.h"

#include "llvm/Support/FormatVariadicDetails.h"

#include <llvm/Support/FormatVariadic.h>
#include <llvm/Support/raw_ostream.h>
#include <string>

namespace typeart::config::pass {

struct PassStdArgsEq final {
#define TYPEART_CONFIG_OPTION(name, path, type, def_value, description, upper_path) \
  static constexpr char name[] = path "=";
#include "support/ConfigurationBaseOptions.h"
#undef TYPEART_CONFIG_OPTION
};

llvm::Expected<TypeARTConfigOptions> parse_typeart_config(llvm::StringRef parameters) {
  return parse_typeart_config_with_occurrence(parameters).first;
}

PassConfig parse_typeart_config_with_occurrence(llvm::StringRef parameters) {
  LOG_DEBUG("Parsing string: " << parameters)
  TypeARTConfigOptions result;
  OptOccurrenceMap occurrence_map;
  bool global_set{false};
  bool stack_set{false};

  while (!parameters.empty()) {
    llvm::StringRef parameter_name;
    std::tie(parameter_name, parameters) = parameters.split(';');

    const bool enable = !parameter_name.consume_front("no-");

    if (parameter_name == ConfigStdArgs::heap) {
      result.heap                         = enable;
      occurrence_map[ConfigStdArgs::heap] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::gpu) {
      result.gpu                         = enable;
      occurrence_map[ConfigStdArgs::gpu] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::stack) {
      result.stack                         = enable;
      occurrence_map[ConfigStdArgs::stack] = true;
      stack_set                            = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::global) {
      global_set                            = true;
      result.global                         = enable;
      occurrence_map[ConfigStdArgs::global] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::filter) {
      result.filter                         = enable;
      occurrence_map[ConfigStdArgs::filter] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::stats) {
      result.statistics                    = enable;
      occurrence_map[ConfigStdArgs::stats] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::stack_lifetime) {
      result.stack_lifetime                         = enable;
      occurrence_map[ConfigStdArgs::stack_lifetime] = true;
      continue;
    }

    if (parameter_name.consume_front(PassStdArgsEq::typegen)) {
      result.typegen                         = util::string_to_enum<TypegenImplementation>(parameter_name);
      occurrence_map[ConfigStdArgs::typegen] = true;
      continue;
    }

    if (parameter_name.consume_front(PassStdArgsEq::filter_impl)) {
      result.filter_config.implementation        = util::string_to_enum<analysis::FilterImplementation>(parameter_name);
      occurrence_map[ConfigStdArgs::filter_impl] = true;
      continue;
    }

    if (parameter_name.consume_front(PassStdArgsEq::type_serialization)) {
      result.type_serialization = util::string_to_enum<TypeSerializationImplementation>(parameter_name);
      occurrence_map[ConfigStdArgs::type_serialization] = true;
      continue;
    }

    if (parameter_name.consume_front(PassStdArgsEq::filter_glob)) {
      result.filter_config.glob                  = parameter_name;
      occurrence_map[ConfigStdArgs::filter_glob] = true;
      continue;
    }
    if (parameter_name.consume_front(PassStdArgsEq::filter_glob_deep)) {
      result.filter_config.glob_deep                  = parameter_name;
      occurrence_map[ConfigStdArgs::filter_glob_deep] = true;
      continue;
    }
    if (parameter_name == ConfigStdArgs::analysis_filter_global) {
      result.analysis_config.filter_global                  = enable;
      occurrence_map[ConfigStdArgs::analysis_filter_global] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::analysis_filter_alloca_non_array) {
      result.analysis_config.filter_alloca_non_array                  = enable;
      occurrence_map[ConfigStdArgs::analysis_filter_alloca_non_array] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::analysis_filter_heap_alloc) {
      result.analysis_config.filter_heap_alloc                  = enable;
      occurrence_map[ConfigStdArgs::analysis_filter_heap_alloc] = true;
      continue;
    }

    if (parameter_name == ConfigStdArgs::analysis_filter_pointer_alloc) {
      result.analysis_config.filter_pointer_alloc                  = enable;
      occurrence_map[ConfigStdArgs::analysis_filter_pointer_alloc] = true;
      continue;
    }
    {
      // undefined symbol issue: llvm::formatv("Unknown TypeART option {0} with unparsed list {1}", parameter_name,
      // parameters).str()
      std::string out_string;
      llvm::raw_string_ostream out_stream(out_string);
      out_stream << "Unknown TypeART option " << parameter_name;
      if (!parameters.empty()) {
        out_stream << " with unparsed list " << parameters;
      }
      return {error::make_string_error(out_stream.str()), occurrence_map};
    }
  }
  if (!global_set && stack_set) {
    // Stack implies global
    result.global                         = result.stack;
    occurrence_map[ConfigStdArgs::global] = true;
  }
  return {result, occurrence_map};
}

}  // namespace typeart::config::pass

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 "PassConfiguration.h"
14
15	#include "OptionsUtil.h"
16	#include "analysis/MemInstFinder.h"
17	#include "configuration/Configuration.h"
18	#include "instrumentation/TypeIDProvider.h"
19	#include "support/ConfigurationBase.h"
20	#include "support/ConfigurationBaseOptions.h"
21	#include "support/Error.h"
22	#include "support/Logger.h"
23
24	#include "llvm/Support/FormatVariadicDetails.h"
25
26	#include <llvm/Support/FormatVariadic.h>
27	#include <llvm/Support/raw_ostream.h>
28	#include <string>
29
30	namespace typeart::config::pass {
31
32	struct PassStdArgsEq final {
33	#define TYPEART_CONFIG_OPTION(name, path, type, def_value, description, upper_path) \
34	static constexpr char name[] = path "=";
35	#include "support/ConfigurationBaseOptions.h"
36	#undef TYPEART_CONFIG_OPTION
37	};
38
39	llvm::Expected<TypeARTConfigOptions> parse_typeart_config(llvm::StringRef parameters) {	7,154✔
40	return parse_typeart_config_with_occurrence(parameters).first;	7,154✔
41	}	×
42
43	PassConfig parse_typeart_config_with_occurrence(llvm::StringRef parameters) {	15,253✔
44	LOG_DEBUG("Parsing string: " << parameters)
45	TypeARTConfigOptions result;	15,253✔
46	OptOccurrenceMap occurrence_map;	15,253✔
47	bool global_set{false};	15,253✔
48	bool stack_set{false};	15,253✔
49
50	while (!parameters.empty()) {	33,021✔
51	llvm::StringRef parameter_name;	17,768✔
52	std::tie(parameter_name, parameters) = parameters.split(';');	17,768✔
53
54	const bool enable = !parameter_name.consume_front("no-");	17,768✔
55
56	if (parameter_name == ConfigStdArgs::heap) {	17,768✔
57	result.heap = enable;	4,250✔
58	occurrence_map[ConfigStdArgs::heap] = true;	4,250✔
59	continue;	4,250✔
60	}
61
62	if (parameter_name == ConfigStdArgs::gpu) {	13,518✔
NEW 63	result.gpu = enable;	×
NEW 64	occurrence_map[ConfigStdArgs::gpu] = true;	×
NEW 65	continue;	×
66	}
67
68	if (parameter_name == ConfigStdArgs::stack) {	13,518✔
69	result.stack = enable;	2,170✔
70	occurrence_map[ConfigStdArgs::stack] = true;	2,170✔
71	stack_set = true;	2,170✔
72	continue;	2,170✔
73	}
74
75	if (parameter_name == ConfigStdArgs::global) {	11,348✔
76	global_set = true;	30✔
77	result.global = enable;	30✔
78	occurrence_map[ConfigStdArgs::global] = true;	30✔
79	continue;	30✔
80	}
81
82	if (parameter_name == ConfigStdArgs::filter) {	11,318✔
83	result.filter = enable;	30✔
84	occurrence_map[ConfigStdArgs::filter] = true;	30✔
85	continue;	30✔
86	}
87
88	if (parameter_name == ConfigStdArgs::stats) {	11,288✔
89	result.statistics = enable;	7,199✔
90	occurrence_map[ConfigStdArgs::stats] = true;	7,199✔
91	continue;	7,199✔
92	}
93
94	if (parameter_name == ConfigStdArgs::stack_lifetime) {	4,089✔
95	result.stack_lifetime = enable;	75✔
96	occurrence_map[ConfigStdArgs::stack_lifetime] = true;	75✔
97	continue;	75✔
98	}
99
100	if (parameter_name.consume_front(PassStdArgsEq::typegen)) {	4,014✔
101	result.typegen = util::string_to_enum<TypegenImplementation>(parameter_name);	2,904✔
102	occurrence_map[ConfigStdArgs::typegen] = true;	2,904✔
103	continue;	2,904✔
104	}
105
106	if (parameter_name.consume_front(PassStdArgsEq::filter_impl)) {	1,110✔
107	result.filter_config.implementation = util::string_to_enum<analysis::FilterImplementation>(parameter_name);	30✔
108	occurrence_map[ConfigStdArgs::filter_impl] = true;	30✔
109	continue;	30✔
110	}
111
112	if (parameter_name.consume_front(PassStdArgsEq::type_serialization)) {	1,080✔
113	result.type_serialization = util::string_to_enum<TypeSerializationImplementation>(parameter_name);	930✔
114	occurrence_map[ConfigStdArgs::type_serialization] = true;	930✔
115	continue;	930✔
116	}
117
118	if (parameter_name.consume_front(PassStdArgsEq::filter_glob)) {	150✔
119	result.filter_config.glob = parameter_name;	30✔
120	occurrence_map[ConfigStdArgs::filter_glob] = true;	30✔
121	continue;	30✔
122	}
123	if (parameter_name.consume_front(PassStdArgsEq::filter_glob_deep)) {	120✔
124	result.filter_config.glob_deep = parameter_name;	×
125	occurrence_map[ConfigStdArgs::filter_glob_deep] = true;	×
126	continue;	×
127	}
128	if (parameter_name == ConfigStdArgs::analysis_filter_global) {	120✔
129	result.analysis_config.filter_global = enable;	30✔
130	occurrence_map[ConfigStdArgs::analysis_filter_global] = true;	30✔
131	continue;	30✔
132	}
133
134	if (parameter_name == ConfigStdArgs::analysis_filter_alloca_non_array) {	90✔
135	result.analysis_config.filter_alloca_non_array = enable;	30✔
136	occurrence_map[ConfigStdArgs::analysis_filter_alloca_non_array] = true;	30✔
137	continue;	30✔
138	}
139
140	if (parameter_name == ConfigStdArgs::analysis_filter_heap_alloc) {	60✔
141	result.analysis_config.filter_heap_alloc = enable;	30✔
142	occurrence_map[ConfigStdArgs::analysis_filter_heap_alloc] = true;	30✔
143	continue;	30✔
144	}
145
146	if (parameter_name == ConfigStdArgs::analysis_filter_pointer_alloc) {	30✔
147	result.analysis_config.filter_pointer_alloc = enable;	30✔
148	occurrence_map[ConfigStdArgs::analysis_filter_pointer_alloc] = true;	30✔
149	continue;	30✔
150	}
151	{
152	// undefined symbol issue: llvm::formatv("Unknown TypeART option {0} with unparsed list {1}", parameter_name,
153	// parameters).str()
154	std::string out_string;	×
155	llvm::raw_string_ostream out_stream(out_string);	×
156	out_stream << "Unknown TypeART option " << parameter_name;	×
157	if (!parameters.empty()) {	×
158	out_stream << " with unparsed list " << parameters;	×
159	}	×
160	return {error::make_string_error(out_stream.str()), occurrence_map};	×
161	}	×
162	}
163	if (!global_set && stack_set) {	15,253✔
164	// Stack implies global
165	result.global = result.stack;	2,140✔
166	occurrence_map[ConfigStdArgs::global] = true;	2,140✔
167	}	2,140✔
168	return {result, occurrence_map};	15,253✔
169	}	15,253✔
170
171	} // namespace typeart::config::pass

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