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

85.71

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

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

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