Boost Spirit-使用-O1构建项目，但不使用-O2构建项目

Question

我有一个使用Boost Spirit X3的小项目（类似于他们的示例-https://github.com/cierelabs/x3_fun/ ），它是在debug中构建的，而不是在发布中构建的。

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定义（这是从Spirit生成的核心函数）。

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";
    }
}

Answer 1

我已经设法自己修复了。

解决方案：将#include "grammar_def.hpp"添加到main.cpp 。

发生了什么： BOOST_SPIRIT_DEFINE声明了内联函数模板。 如果没有立即在所有给定的翻译单元中使用它们，则将所有内容剥离。 它们必须在使用x3::phrase_parse的同一个TU中可见，否则编译器将认为它们是不必要的-因此未定义参考错误。

编辑：问题的根源是精神中的错误。 这个答案只是TU机制的一种解决方法。 请参阅其他答案以获取适当的解决方案。

Answer 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应该解决的问题，但...

   但是错误消息不会消失，这很可能是因为Spirit中的错误。 它使用规则的属性类型实例化parse_rule ，并且默认值为non-const 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将为所有人解决此问题。