太多的部分,汇编程序错误,使用boost :: spirit

Question

我正在为Java的一个子集编写编译器boost::spirit,用于lexing和解析.在编译词法分析器/解析器阶段期间,编译器消耗1.6GBRAM(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'到我的编译器标志,允许汇编程序处理编译器输出,但正如我所看到的,这只是时间问题,直到我遇到同样的问题,即使使用小优化标志.

检查,使用大小优化的对象文件(ast_generate.o)objdump告诉我,我正在生成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. 是error(too many sections (X))中的数字,要生成的部分数,还是错误代码？
2. 为什么为每种数据类型生成一个部分？
3. 我该怎么做,以避免必须传递'-Os'给我的编译器.也就是说,我该怎样做才能解决问题,而不是解决它？
4. 将词法分析器和解析阶段分成两个不同的阶段(和编译单元),只通过词法分析器迭代器连接帮助我吗？

注意; 我正在编译使用cygwin64.

Answer 1

我在这里做了一些黑客攻击并重构了一些东西以显示非运行时多态的样式:

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

我希望它不会增加编译时间:)(我实际上并没有把语法分开,但它变小了).

特征:

• 不再有堆分配的AST节点(甚至不像树expression和/或树statement); 因此没有更明确的克隆和/或虚假的const成员.

• 我已经用Maybe替换了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);
  }
  

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

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

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

  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适应功能的需求减少,Parser本身缩小了

• 请注意,我现在选择忘记 LexerPosition信息(以前在基类中隐藏',现在已经消失了).有示出如何使用一个编译器教程示例qi::on_error(qi::success, ...)以非常优雅连接源位置信息,以选择的阿斯特节点(非侵入).

• ast_helpers我预计可能存在许多有用的基于特征的谓词(例如is_lvalue或者is_true_const),而不是各种谓词.我当选为"保持"的助手或多或少原来的样子(这可能是完全错误的,我没有测试任何东西).

• 我普遍试图将值传递的参数替换为传递const&(比较例如ast_pp.hpp),但我知道我已经留下了一些点,因为任务足够大了.

GIANT免责声明:我可能以各种方式打破了解析器.我没有尝试用它解析任何东西.编辑按原样提供,没有任何使用要求.我以不同的方式解决了类似的问题(曾经是traits::tranform_attribute<>专业化,曾经是一个较大的语义行为at_c<>,以及其他一些方法):

我的目标是向你展示我在提到的时候的想法

• 显着减少动态多态性,
• 避免语义动作
• 在可能的情况下采用强化构造,以实现与精神的更多"自动化"整合
• 显示各种想法,你可以从中选择你喜欢的:/