25212948956

Committed 01 May 2026 11:37AM UTC coverage: 89.288% (-1.0%) from 90.246%

Build # 25212948956

Build Type

Pull #188

github

Committed by

web-flow

Commit Message

Merge f285f0e8f into 278119205

Pull Request Pull Request #188: GPU memory allocation support

Coverage Stats

214 of 298 new or added lines in 20 files covered. (71.81%)

1 existing line in 1 file now uncovered.

5076 of 5685 relevant lines covered (89.29%)

43440.6 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) {	11,388✔
40	return parse_typeart_config_with_occurrence(parameters).first;	11,388✔
41	}	×
42
43	PassConfig parse_typeart_config_with_occurrence(llvm::StringRef parameters) {	24,085✔
44	LOG_DEBUG("Parsing string: " << parameters)
45	TypeARTConfigOptions result;	24,085✔
46	OptOccurrenceMap occurrence_map;	24,085✔
47	bool global_set{false};	24,085✔
48	bool stack_set{false};	24,085✔
49
50	while (!parameters.empty()) {	52,763✔
51	llvm::StringRef parameter_name;	28,678✔
52	std::tie(parameter_name, parameters) = parameters.split(';');	28,678✔
53
54	const bool enable = !parameter_name.consume_front("no-");	28,678✔
55
56	if (parameter_name == ConfigStdArgs::heap) {	28,678✔
57	result.heap = enable;	6,542✔
58	occurrence_map[ConfigStdArgs::heap] = true;	6,542✔
59	continue;	6,542✔
60	}
61
62	if (parameter_name == ConfigStdArgs::gpu) {	22,136✔
NEW 63	result.gpu = enable;	×
NEW 64	occurrence_map[ConfigStdArgs::gpu] = true;	×
NEW 65	continue;	×
66	}
67
68	if (parameter_name == ConfigStdArgs::stack) {	22,136✔
69	result.stack = enable;	3,340✔
70	occurrence_map[ConfigStdArgs::stack] = true;	3,340✔
71	stack_set = true;	3,340✔
72	continue;	3,340✔
73	}
74
75	if (parameter_name == ConfigStdArgs::global) {	18,796✔
76	global_set = true;	46✔
77	result.global = enable;	46✔
78	occurrence_map[ConfigStdArgs::global] = true;	46✔
79	continue;	46✔
80	}
81
82	if (parameter_name == ConfigStdArgs::filter) {	18,750✔
83	result.filter = enable;	46✔
84	occurrence_map[ConfigStdArgs::filter] = true;	46✔
85	continue;	46✔
86	}
87
88	if (parameter_name == ConfigStdArgs::stats) {	18,704✔
89	result.statistics = enable;	11,457✔
90	occurrence_map[ConfigStdArgs::stats] = true;	11,457✔
91	continue;	11,457✔
92	}
93
94	if (parameter_name == ConfigStdArgs::stack_lifetime) {	7,247✔
95	result.stack_lifetime = enable;	115✔
96	occurrence_map[ConfigStdArgs::stack_lifetime] = true;	115✔
97	continue;	115✔
98	}
99
100	if (parameter_name.consume_front(PassStdArgsEq::typegen)) {	7,132✔
101	result.typegen = util::string_to_enum<TypegenImplementation>(parameter_name);	5,542✔
102	occurrence_map[ConfigStdArgs::typegen] = true;	5,542✔
103	continue;	5,542✔
104	}
105
106	if (parameter_name.consume_front(PassStdArgsEq::filter_impl)) {	1,590✔
107	result.filter_config.implementation = util::string_to_enum<analysis::FilterImplementation>(parameter_name);	46✔
108	occurrence_map[ConfigStdArgs::filter_impl] = true;	46✔
109	continue;	46✔
110	}
111
112	if (parameter_name.consume_front(PassStdArgsEq::type_serialization)) {	1,544✔
113	result.type_serialization = util::string_to_enum<TypeSerializationImplementation>(parameter_name);	1,314✔
114	occurrence_map[ConfigStdArgs::type_serialization] = true;	1,314✔
115	continue;	1,314✔
116	}
117
118	if (parameter_name.consume_front(PassStdArgsEq::filter_glob)) {	230✔
119	result.filter_config.glob = parameter_name;	46✔
120	occurrence_map[ConfigStdArgs::filter_glob] = true;	46✔
121	continue;	46✔
122	}
123	if (parameter_name.consume_front(PassStdArgsEq::filter_glob_deep)) {	184✔
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) {	184✔
129	result.analysis_config.filter_global = enable;	46✔
130	occurrence_map[ConfigStdArgs::analysis_filter_global] = true;	46✔
131	continue;	46✔
132	}
133
134	if (parameter_name == ConfigStdArgs::analysis_filter_alloca_non_array) {	138✔
135	result.analysis_config.filter_alloca_non_array = enable;	46✔
136	occurrence_map[ConfigStdArgs::analysis_filter_alloca_non_array] = true;	46✔
137	continue;	46✔
138	}
139
140	if (parameter_name == ConfigStdArgs::analysis_filter_heap_alloc) {	92✔
141	result.analysis_config.filter_heap_alloc = enable;	46✔
142	occurrence_map[ConfigStdArgs::analysis_filter_heap_alloc] = true;	46✔
143	continue;	46✔
144	}
145
146	if (parameter_name == ConfigStdArgs::analysis_filter_pointer_alloc) {	46✔
147	result.analysis_config.filter_pointer_alloc = enable;	46✔
148	occurrence_map[ConfigStdArgs::analysis_filter_pointer_alloc] = true;	46✔
149	continue;	46✔
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) {	24,085✔
164	// Stack implies global
165	result.global = result.stack;	3,294✔
166	occurrence_map[ConfigStdArgs::global] = true;	3,294✔
167	}	3,294✔
168	return {result, occurrence_map};	24,085✔
169	}	24,085✔
170
171	} // namespace typeart::config::pass

tudasc / TypeART / 25212948956

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