Boost Spirit - проект строится с -O1, но не с -O2

У меня есть небольшой проект (похожий на их пример - https://github.com/cierelabs/x3_fun/), использующий Boost Spirit X3, и он построен на отладке, но не на выпуске.

Рекомендация о структуре программы X3 + другой пример: https://www.boost.org/doc/libs/1_69_0/libs/spirit/doc/x3/html/spirit_x3/tutorials/minimal.html

компилятор: GCC 8.2.0

ОС: Windows 10

После git bisect и некоторых экспериментов по настройке проекта я сузил проблему до флага оптимизации компилятора.

это строит:

g++ -std=c++17 -O1 -pedantic -Wall -Wextra -c -fmessage-length=0

это не строить:

g++ -std=c++17 -O2 -pedantic -Wall -Wextra -c -fmessage-length=0

Ошибка, которую я получаю:

C:/msys64/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.2.0/../../../../x86_64-w64-mingw32/bin/ld.exe: ./src/main.o:main.cpp:(.text+0x2156): undefined reference to `bool fs::parser::parse_rule<__gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >, boost::spirit::x3::unused_type, boost::spirit::x3::unused_type const>(boost::spirit::x3::rule<fs::parser::whitespace_class, boost::spirit::x3::unused_type, false>, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > >&, __gnu_cxx::__normal_iterator<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&, boost::spirit::x3::unused_type const&, boost::spirit::x3::unused_type const&)'

Похоже, оптимизатор удаляет parse_rule определение (которое является основной функцией, порожденной Духом), которое действительно необходимо.

nm -C main.o сброс (слева есть -O2, право -O1): https://www.diffchecker.com/YAFmJkbN

nm -C grammar.o сброс (слева есть -O2, право -O1): https://www.diffchecker.com/6dUgMiEK

nm -C utility.o сброс (слева есть -O2, право -O1): https://www.diffchecker.com/mXGf2Hx7 (без разницы, кроме адресов)

Первоначально я думал, что проблема похожа на ошибку компоновщика C++: неопределенные ссылки только на оптимизированную сборку, но у меня нет шаблонов в исходных файлах, кроме того, что Boost может определить в своих макросах.

Что может быть причиной того, что оптимизатор ошибочно удаляет определение функции?

Код:

grammar.hpp

#pragma once
#include <boost/spirit/home/x3.hpp>
#include <tuple>
#include <utility>

namespace fs::parser
{

namespace x3 = boost::spirit::x3;
// symbols that denote filter's language constants
struct booleans_ : x3::symbols<bool>
{
    booleans_()
    {
        add
            ("True", true)
            ("False", false)
        ;
    }

};
const booleans_ booleans;

// some constants to aovid code duplication
constexpr auto keyword_boolean = "Boolean";
constexpr auto keyword_number  = "Number";
constexpr auto keyword_true    = "True";
constexpr auto keyword_false   = "False";
constexpr auto assignment_operator = '=';
constexpr auto newline_character   = '\n';

auto set_first = [](auto& ctx){ _val(ctx).first += _attr(ctx); };
auto set_second = [](auto& ctx){ _val(ctx).second += _attr(ctx); };

using x3::raw;
using x3::lexeme;
using x3::alpha;
using x3::alnum;
using x3::char_;
using x3::lit;

// comment - a line that starts with #
using comment_type = x3::rule<class comment_class>;
BOOST_SPIRIT_DECLARE(comment_type)

// identifier
using identifier_type = x3::rule<class identifier_class, std::string>;
BOOST_SPIRIT_DECLARE(identifier_type)

// whitespace
// Filter Spirit grammar skips any whitespace except newline character
using whitespace_type = x3::rule<class whitespace_class>;
BOOST_SPIRIT_DECLARE(whitespace_type)

// string
using string_type = x3::rule<class string_class, std::string>;
BOOST_SPIRIT_DECLARE(string_type)

// boolean definition: Boolean b = True
using constant_boolean_definition_type = x3::rule<class constant_boolean_definition_class, std::pair<std::string, bool>>;
BOOST_SPIRIT_DECLARE(constant_boolean_definition_type)

// number definition: Number n = 3
using constant_number_definition_type = x3::rule<class constant_number_definition_class, std::pair<std::string, int>>;
BOOST_SPIRIT_DECLARE(constant_number_definition_type)

// constants
using constant_definition_type = x3::rule<class constant_definition_class, boost::variant<constant_boolean_definition_type::attribute_type, constant_number_definition_type::attribute_type>>;
BOOST_SPIRIT_DECLARE(constant_definition_type)

// filter language consists of lines, of which every is a comment or some code
using code_line_type = x3::rule<class code_line_class, boost::optional<constant_definition_type::attribute_type>>;
BOOST_SPIRIT_DECLARE(code_line_type)

// the entire language grammar
using grammar_type = x3::rule<class grammar_class, std::vector<code_line_type::attribute_type>>;
BOOST_SPIRIT_DECLARE(grammar_type)

using skipper_type = whitespace_type;

// Boost Spirit recommends that this should be in a separate config.hpp file but
// in our case we need skipper type to be visible so we place configuration here
using iterator_type = std::string::const_iterator;
using context_type = x3::phrase_parse_context<skipper_type>::type;


}

namespace fs
{

parser::grammar_type grammar();
parser::skipper_type skipper();

}

grammar_def.hpp

#pragma once
#include "grammar.hpp"

namespace fs::parser
{

const comment_type comment = "comment";
const auto comment_def = lexeme['#' >> *(char_ - newline_character)];
BOOST_SPIRIT_DEFINE(comment)

const identifier_type identifier = "identifier";
const auto identifier_def = lexeme[(alpha | '_') >> *(alnum | '_')];
BOOST_SPIRIT_DEFINE(identifier)

const whitespace_type whitespace = "whitespace";
const auto whitespace_def = x3::space - newline_character;
BOOST_SPIRIT_DEFINE(whitespace)

const string_type string = "string";
const auto string_def = lexeme['"' >> +(char_ - '"') >> '"'];
BOOST_SPIRIT_DEFINE(string)

const constant_boolean_definition_type constant_boolean_definition = "Boolean definition";
const auto constant_boolean_definition_def = lit(keyword_boolean) >> identifier[set_first] >> lit(assignment_operator) >> booleans[set_second];
BOOST_SPIRIT_DEFINE(constant_boolean_definition)

const constant_number_definition_type constant_number_definition = "Number definition";
const auto constant_number_definition_def = lit(keyword_number) >> identifier[set_first] >> lit(assignment_operator) >> x3::int_[set_second];
BOOST_SPIRIT_DEFINE(constant_number_definition)

const constant_definition_type constant_definition = "value definition";
const auto constant_definition_def = constant_boolean_definition | constant_number_definition;
BOOST_SPIRIT_DEFINE(constant_definition)

const code_line_type code_line = "line";
const auto code_line_def = newline_character | comment | constant_definition;
BOOST_SPIRIT_DEFINE(code_line)

const grammar_type grammar = "code";
const auto grammar_def = *code_line;
BOOST_SPIRIT_DEFINE(grammar)

}

namespace fs
{

inline
parser::grammar_type grammar()
{
    return parser::grammar;
}

inline
parser::skipper_type skipper()
{
    return parser::whitespace;
}

}

grammar.cpp

#include "grammar_def.hpp"

namespace fs::parser
{

BOOST_SPIRIT_INSTANTIATE(grammar_type, iterator_type, context_type)

}

utility.hpp

#pragma once

#include <string>
#include <optional>

namespace fs::utility
{

bool file_exists(const char* path);
inline
bool file_exists(const std::string& path) { return file_exists(path.c_str()); }

std::optional<std::string> load_file(const char* file_path);
inline
std::optional<std::string> load_file(const std::string& file_path) { return load_file(file_path.c_str()); }

}

utility.cpp

#include "utility.hpp"
#include <fstream>
#include <sys/types.h>
#include <sys/stat.h>

namespace fs::utility
{

bool file_exists(const char* path)
{
    struct stat buffer;
    return stat(path, &buffer) == 0;
}

std::optional<std::string> load_file(const char* file_path)
{
    std::ifstream file(file_path);

    if (!file.good())
        return {};

    return std::string(std::istreambuf_iterator<char>{file}, {});
}

}

main.cpp

#include "utility.hpp"
#include "grammar.hpp"

#include <iostream>

bool parse(std::string const& source)
{
    namespace x3 = boost::spirit::x3;

    fs::parser::iterator_type it = source.begin();
    const fs::parser::iterator_type end = source.end();
    fs::parser::grammar_type::attribute_type data;

    const bool result = x3::phrase_parse(
        it,
        end,
        fs::grammar(),
        fs::skipper(),
        data
    );

    if (it != end) // fail if we did not get a full match
    {
        std::cout << "parse failure at pos: " << it - source.begin() << "\n";
        return false;
    }

    return result;
}


int main(int argc, char* argv[])
{
    if (argc < 2)
    {
        std::cout << "usage: " << "./program filepath\n";
        return -1;
    }

    if (parse(fs::utility::load_file(argv[1]).value()))
    {
        std::cout << "parse successful\n";
    }
    else
    {
        std::cout << "parse failure\n";
    }
}

2 ответа

Решение
  1. parser::grammar_type grammar() а также parser::skipper_type skipper() не экспортируются (я получил ошибку компоновщика по этому поводу, но вы не упомянули об этом в своем вопросе). Переместить их в grammar.cpp (и удалить inline на них конечно) решить вопрос.

  2. Отсутствует инстанцирование шкипера (об этом вы сообщаете только об ошибке). размещение BOOST_SPIRIT_INSTANTIATE(whitespace_type, iterator_type, boost::spirit::x3::unused_type) в grammar.cpp должен решить проблему, но...

    Но сообщение об ошибке не исчезнет, ​​и это, скорее всего, из-за ошибки в Духе. Это создает parse_rule с типом атрибута правила, и по умолчанию не является константой unused_type, но похоже, что где-то при пропуске принимает атрибут по const ref. Чтобы обойти это, укажите правило шкипера с типом атрибута const x3::rule<class whitespace_class, boost::spirit::x3::unused_type const>,

Результат https://gist.github.com/Kojoley/f7766422a5b6fd9e34b4b9d434325336.

Обновление: PR https://github.com/boostorg/spirit/pull/437 решит проблему для всех.

Мне удалось это исправить самому.

Решение: добавить #include "grammar_def.hpp" в main.cpp,

Что происходило: BOOST_SPIRIT_DEFINE объявляет встроенные шаблоны функций. Все они удаляются, если они не используются сразу в каком-либо заданном переводческом блоке. Они должны быть видны в том же Ту, где x3::phrase_parse используется или иным образом, они будут считаться ненужными компилятором - следовательно, неопределенная ошибка ссылки.

Изменить: источник проблемы является ошибка в духе. Этот ответ - просто обход механизма TU. Смотрите другой ответ для правильного решения.

Другие вопросы по тегам