我正在为 Java 的一个子集编写编译器，使用 boost::spirit 进行词法分析和解析。在词法分析器/解析器阶段的编译期间，编译器消耗 1.6GB RAM (g++ (GCC) 4.8.1)，但这不是问题，因为有很多这台机器上的内存。

然而，问题在于当编译器完成并且汇编器开始运行时(GNU assembler (GNU Binutils) 2.23.52.20130604)，它崩溃了；

as: build/src/ast_generate.o: too many sections (33098)
/tmp/cc0ZyvKK.s: Assembler messages:
/tmp/cc0ZyvKK.s: Fatal error: can't write build/src/ast_generate.o: File too big
as: build/src/ast_generate.o: too many sections (33098)
/tmp/cc0ZyvKK.s: Fatal error: can't close build/src/ast_generate.o: File too big
scons: *** [build/src/ast_generate.o] Error 1

将 '-Os' 添加到我的编译器标志中，允许汇编器处理编译器输出，但正如我所见，这只是时间问题，直到我遇到同样的问题，即使有小的优化标志。

使用 objdump 检查大小优化的目标文件 (ast_generate.o)，告诉我正在生成 pe-x86-64，这是我对 Windows 的期望。

2358 生成的部分令我震惊。主要是因为它似乎为 boost::spirit 的每个部分生成了一个部分;

 CONTENTS, ALLOC, LOAD, READONLY, DATA, LINK_ONCE_DISCARD
 ...
 60 .pdata$_ZNK5boost5lexer6detail8end_node9unique_idEv 0000000c  0000000000000000  0000000000000000  00030750  2**2
 61 .text$_ZNK5boost5lexer6detail8end_node11lexer_stateEv 00000010  0000000000000000  0000000000000000  0003075c  2**4
 ...

所以我的问题是；

1. 错误中的数字是(too many sections (X))，要生成的节数，还是错误代码？
2. 为什么要为每种数据类型生成一个部分？
3. 我该怎么做才能避免将'-Os' 传递给我的编译器。也就是说，我可以做些什么来解决问题，而不是解决问题？
4. 将词法分析器和解析阶段拆分为两个不同的阶段(和编译单元)，仅通过词法分析器迭代器连接是否对我有帮助？

注意；我正在使用 cygwin64 进行编译。

最佳答案

我在这里做了一些修改并重构了一些东西来展示非运行时多态风格:

• https://bitbucket.org/sehe/joos2compiler-refactor (基于您的 12d01e5 提交)。

我希望它不会增加编译时间 :)(我实际上还没有抽出时间拆分语法，但它变小了)。

特点:

• 不再有堆分配的 AST 节点(甚至对于像 expression 和/或 statement 这样的树也不行)；因此不再有明确的克隆和/或虚假的 const 成员。

• 我已将 Maybe.hpp 替换为

  #pragma once
  #include <boost/optional.hpp>
  
  template <typename T> using Maybe = boost::optional<T>;
  

  它是快速而肮脏的，但它全部编译

• 我已经用我自己的小努力替换了开放类型切换(我无法让它工作；还有 boost-variant，它都是内置的):

  namespace visitor_galore // this is my make-shift replacement for typeswitch (I couldn't find it/make it work)
  {
      template<typename T, class...Fs> struct visitor_t;
  
      template<typename T, class F1, class...Fs>
      struct visitor_t<T, F1, Fs...> : F1, visitor_t<T, Fs...>::type {
          typedef visitor_t type;
          visitor_t(F1 head, Fs...tail) : F1(head), visitor_t<T, Fs...>::type(tail...) {}
  
          using F1::operator();
          using visitor_t<T, Fs...>::type::operator();
      };
  
      template<typename T, class F> struct visitor_t<T, F> : F, boost::static_visitor<T> {
          typedef visitor_t type;
          visitor_t(F f) : F(f) {}
          using F::operator();
      };
  
      template<typename T=void, class...Fs>
      typename visitor_t<T, Fs...>::type make_visitor(Fs...x) { return {x...}; }
  }
  
  using visitor_galore::make_visitor;
  

  要了解它是如何使用的，请查看例如ast_pp.cpp :

  void pretty_print(expression_incdec const& exp)
  {
       boost::apply_visitor(
              make_visitor(
                  [&exp](inc_dec_op_preinc const& op)  { std::cout << "++"; pretty_print(exp.variable); }, 
                  [&exp](inc_dec_op_predec const& op)  { std::cout << "--"; pretty_print(exp.variable); }, 
                  [&exp](inc_dec_op_postinc const& op) { pretty_print(exp.variable); std::cout << "++"; }, 
                  [&exp](inc_dec_op_postdec const& op) { pretty_print(exp.variable); std::cout << "--"; }
                  )
              , exp.operatur);
  }
  

  BONUS 如果您不太关心在分支中列出所有类型，例如因为它们都默认调用相同的自由函数(或重载)，所以您可以使用多态访问者:

  static const struct pretty_print_visitor_ : boost::static_visitor<>
  {
      template<typename T>
      void operator ()(T const& v) const { pretty_print(v); }
  } pretty_print_visitor;
  

  例如现在您可以替换 expression& 的 24 个分支:

  boost::apply_visitor(
          make_visitor(
              [](expression_binop const& exp)              { pretty_print(exp); }, 
              [](expression_unop const& exp)               { pretty_print(exp); }, 
              [](expression_integer_constant const& exp)   { pretty_print(exp); }, 
              [](expression_character_constant const& exp) { pretty_print(exp); }, 
              [](expression_string_constant const& exp)    { pretty_print(exp); }, 
              [](expression_boolean_constant const& exp)   { pretty_print(exp); }, 
              [](expression_null const& exp)               { pretty_print(exp); }, 
              [](expression_this const& exp)               { pretty_print(exp); }, 
              [](expression_static_invoke const& exp)      { pretty_print(exp); }, 
              [](expression_non_static_invoke const& exp)  { pretty_print(exp); }, 
              [](expression_simple_invoke const& exp)      { pretty_print(exp); }, 
              [](expression_ambiguous_invoke const& exp)   { pretty_print(exp); }, 
              [](expression_new const& exp)                { pretty_print(exp); }, 
              [](expression_new_array const& exp)          { pretty_print(exp); }, 
              [](expression_lvalue const& exp)             { pretty_print(exp); }, 
              [](expression_assignment const& exp)         { pretty_print(exp); }, 
              [](expression_incdec const& exp)             { pretty_print(exp); }, 
              [](expression_cast const& exp)               { pretty_print(exp); }, 
              [](expression_ambiguous_cast const& exp)     { pretty_print(exp); }, 
              [](expression_instance_of const& exp)        { pretty_print(exp); }, 
              [](expression_parentheses const& exp)        { pretty_print(exp); },
              [](lvalue_non_static_field const& exp)       { pretty_print(exp); },
              [](lvalue_array const& exp)                  { pretty_print(exp); },
              [](lvalue_ambiguous_name const& exp)         { pretty_print(exp); }
         )
          , exp);
  

  通过一个简单的

  boost::apply_visitor(pretty_print_visitor, exp);
  

• 注意我在几个地方放了 // TODO或 // FIXME评论(值得注意的是 concat ，它不想再为我编译)。

• 请注意，Ast 类变得明显更简单(尤其是在内存分配方面更加正确)

• 请注意，由于对语义操作和 Phoenix 适配函数的需求减少，解析器本身缩小了

• 请注意，我选择暂时忘记 LexerPosition 信息(过去“隐藏”在基类中，现在消失了)。有一个编译器教程示例展示了如何使用 qi::on_error(qi::success, ...) 非常优雅地将源位置信息附加到选定 Ast 节点(非侵入式)。

• 代替ast_helpers中的各种谓词我预计可能会有许多有用的基于特征的谓词(例如 is_lvalue 或 is_true_const )。我选择或多或少地“保留”助手原样(这可能是完全错误的，我还没有测试任何东西)。

• 我一直在尝试将按值传递的参数替换为按 const& 传递的参数( compare e.g. the ast_pp.hpp ) 但我知道我已经留下了一些地方，因为任务已经足够大了。

巨大的免责声明:我可能以各种方式破坏了解析器。我没有尝试用它解析任何东西。编辑内容按原样提供，没有任何有用性。我已经以不同的方式解决了类似的问题(曾经是 traits::tranform_attribute<> 特化，曾经是 at_c<> 的大型语义 Action ，以及其他一些方法):

目的是向您展示我提到也许时的想法

• 显着减少动态多态性，
• 避免语义 Action
• 在可能的情况下采用增强结构，以获得与精神的更多“自动魔法”整合
• 展示了您可以从中选出您最喜欢的各种想法:/

关于c++ - 段太多，汇编错误，使用 boost::spirit，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18694547/