12973752603

Committed 26 Jan 2025 10:22AM UTC coverage: 87.53%. First build

Build # 12973752603

Build Type

Pull #152

github

Committed by

web-flow

Commit Message

Merge 47346d838 into bddfb53e4

Pull Request Pull Request #152: Pass configuration parser

Run Details

90 of 215 new or added lines in 10 files covered. (41.86%)

3959 of 4523 relevant lines covered (87.53%)

113474.42 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

10.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
NEW 38	llvm::Expected<TypeARTConfigOptions> parse_typeart_config(llvm::StringRef parameters) {	×
NEW 39	return parse_typeart_config_with_occurrence(parameters).first;	×
NEW 40	}	×
41
42	PassConfig parse_typeart_config_with_occurrence(llvm::StringRef parameters) {	1,630✔
43	LOG_DEBUG("Parsing string: " << parameters)
44	TypeARTConfigOptions result;	1,630✔
45	OptOccurrenceMap occurrence_map;	1,630✔
46	bool global_set{false};	1,630✔
47	bool stack_set{false};	1,630✔
48
49	while (!parameters.empty()) {	1,630✔
NEW 50	llvm::StringRef parameter_name;	×
NEW 51	std::tie(parameter_name, parameters) = parameters.split(';');	×
52
NEW 53	const bool enable = !parameter_name.consume_front("no-");	×
54
NEW 55	if (parameter_name == ConfigStdArgs::heap) {	×
NEW 56	result.heap = enable;	×
NEW 57	occurrence_map[ConfigStdArgs::heap] = true;	×
NEW 58	continue;	×
59	}
60
NEW 61	if (parameter_name == ConfigStdArgs::stack) {	×
NEW 62	result.stack = enable;	×
NEW 63	occurrence_map[ConfigStdArgs::stack] = true;	×
NEW 64	stack_set = true;	×
NEW 65	continue;	×
66	}
67
NEW 68	if (parameter_name == ConfigStdArgs::global) {	×
NEW 69	global_set = true;	×
NEW 70	result.global = enable;	×
NEW 71	occurrence_map[ConfigStdArgs::global] = true;	×
NEW 72	continue;	×
73	}
74
NEW 75	if (parameter_name == ConfigStdArgs::filter) {	×
NEW 76	result.filter = enable;	×
NEW 77	occurrence_map[ConfigStdArgs::filter] = true;	×
NEW 78	continue;	×
79	}
80
NEW 81	if (parameter_name == ConfigStdArgs::stats) {	×
NEW 82	result.statistics = enable;	×
NEW 83	occurrence_map[ConfigStdArgs::stats] = true;	×
NEW 84	continue;	×
85	}
86
NEW 87	if (parameter_name == ConfigStdArgs::stack_lifetime) {	×
NEW 88	result.stack_lifetime = enable;	×
NEW 89	occurrence_map[ConfigStdArgs::stack_lifetime] = true;	×
NEW 90	continue;	×
91	}
92
NEW 93	if (parameter_name.consume_front(PassStdArgsEq::typegen)) {	×
NEW 94	result.typegen = util::string_to_enum<TypegenImplementation>(parameter_name);	×
NEW 95	occurrence_map[ConfigStdArgs::typegen] = true;	×
NEW 96	continue;	×
97	}
98
NEW 99	if (parameter_name.consume_front(PassStdArgsEq::filter_impl)) {	×
NEW 100	result.filter_config.implementation = util::string_to_enum<analysis::FilterImplementation>(parameter_name);	×
NEW 101	occurrence_map[ConfigStdArgs::filter_impl] = true;	×
NEW 102	continue;	×
103	}
104
NEW 105	if (parameter_name.consume_front(PassStdArgsEq::filter_glob)) {	×
NEW 106	result.filter_config.glob = parameter_name;	×
NEW 107	occurrence_map[ConfigStdArgs::filter_glob] = true;	×
NEW 108	continue;	×
109	}
NEW 110	if (parameter_name.consume_front(PassStdArgsEq::filter_glob_deep)) {	×
NEW 111	result.filter_config.glob_deep = parameter_name;	×
NEW 112	occurrence_map[ConfigStdArgs::filter_glob_deep] = true;	×
NEW 113	continue;	×
114	}
NEW 115	if (parameter_name == ConfigStdArgs::analysis_filter_global) {	×
NEW 116	result.analysis_config.filter_global = enable;	×
NEW 117	occurrence_map[ConfigStdArgs::analysis_filter_global] = true;	×
NEW 118	continue;	×
119	}
120
NEW 121	if (parameter_name == ConfigStdArgs::analysis_filter_alloca_non_array) {	×
NEW 122	result.analysis_config.filter_alloca_non_array = enable;	×
NEW 123	occurrence_map[ConfigStdArgs::analysis_filter_alloca_non_array] = true;	×
NEW 124	continue;	×
125	}
126
NEW 127	if (parameter_name == ConfigStdArgs::analysis_filter_heap_alloc) {	×
NEW 128	result.analysis_config.filter_heap_alloc = enable;	×
NEW 129	occurrence_map[ConfigStdArgs::analysis_filter_heap_alloc] = true;	×
NEW 130	continue;	×
131	}
132
NEW 133	if (parameter_name == ConfigStdArgs::analysis_filter_pointer_alloc) {	×
NEW 134	result.analysis_config.filter_pointer_alloc = enable;	×
NEW 135	occurrence_map[ConfigStdArgs::analysis_filter_pointer_alloc] = true;	×
NEW 136	continue;	×
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) {	1,630✔
151	// Stack implies global
NEW 152	result.global = result.stack;	×
NEW 153	occurrence_map[ConfigStdArgs::global] = true;	×
NEW 154	}	×
155	return {result, occurrence_map};	1,630✔
156	}	1,630✔
157
158	} // namespace typeart::config::pass

tudasc / TypeART / 12973752603

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