Merge pull request #1433 from clasp-developers/bytecode-compiler-opt

Bytecode compiler opt

Author: Bike

include/clasp/core/bytecode_compiler.h

@@ -1,6 +1,7 @@
 #ifndef bytecode_compiler_H
 #define bytecode_compiler_H
 
+#include <variant>
 #include <clasp/core/common.h>
 #include <clasp/core/compPackage.fwd.h>
 
@@ -54,6 +55,14 @@ class LexicalVarInfo_O : public VarInfo_O {
   }
 };
 
+struct LexicalVarInfoV {
+  LexicalVarInfoV(LexicalVarInfo_sp info) : _info(info) {};
+  // Because we mutate infos, and store them in lexenvs, we have to
+  // allocate them. This wrapper is just for var_info_v purposes.
+  LexicalVarInfo_sp _info;
+  LexicalVarInfo_sp info() const { return _info; }
+};
+
 FORWARD(SpecialVarInfo);
 class SpecialVarInfo_O : public VarInfo_O {
   LISP_CLASS(comp, CompPkg, SpecialVarInfo_O, "SpecialVarInfo", VarInfo_O);
@@ -74,6 +83,13 @@ class SpecialVarInfo_O : public VarInfo_O {
   CL_DEFMETHOD bool globalp() const { return this->_globalp; }
 };
 
+struct SpecialVarInfoV {
+  SpecialVarInfoV(bool globalp) : _globalp(globalp) {};
+  SpecialVarInfoV(SpecialVarInfo_sp info) : _globalp(info->globalp()) {};
+  bool _globalp;
+  bool globalp() const { return _globalp; }
+};
+
 FORWARD(SymbolMacroVarInfo);
 class SymbolMacroVarInfo_O : public VarInfo_O {
   LISP_CLASS(comp, CompPkg, SymbolMacroVarInfo_O, "SymbolMacroVarInfo", VarInfo_O);
@@ -91,6 +107,13 @@ class SymbolMacroVarInfo_O : public VarInfo_O {
   CL_DEFMETHOD Function_sp expander() const { return this->_expander; }
 };
 
+struct SymbolMacroVarInfoV {
+  SymbolMacroVarInfoV(Function_sp expander) : _expander(expander) {};
+  SymbolMacroVarInfoV(SymbolMacroVarInfo_sp info) : _expander(info->expander()) {};
+  Function_sp _expander;
+  Function_sp expander() const { return _expander; }
+};
+
 FORWARD(ConstantVarInfo);
 class ConstantVarInfo_O : public VarInfo_O {
   LISP_CLASS(comp, CompPkg, ConstantVarInfo_O, "ConstantVarInfo", VarInfo_O);
@@ -107,6 +130,19 @@ class ConstantVarInfo_O : public VarInfo_O {
   CL_DEFMETHOD T_sp value() const { return this->_value; }
 };
 
+struct ConstantVarInfoV {
+  ConstantVarInfoV(T_sp value) : _value(value) {};
+  ConstantVarInfoV(ConstantVarInfo_sp info) : _value(info->value()) {};
+  T_sp _value;
+  T_sp value() const { return _value; }
+};
+
+// non-heaped infos, to avoid consing. see var_info_v.
+// We use this thing instead of monostate for clarity.
+struct NoVarInfoV {};
+
+typedef std::variant<NoVarInfoV, LexicalVarInfoV, SpecialVarInfoV, SymbolMacroVarInfoV, ConstantVarInfoV> VarInfoV;
+
 FORWARD(FunInfo);
 class FunInfo_O : public General_O {
   LISP_ABSTRACT_CLASS(comp, CompPkg, FunInfo_O, "FunInfo", General_O);
@@ -131,6 +167,13 @@ class GlobalFunInfo_O : public FunInfo_O {
   CL_DEFMETHOD T_sp cmexpander() const { return this->_cmexpander; }
 };
 
+struct GlobalFunInfoV {
+  GlobalFunInfoV(T_sp cmexpander) : _cmexpander(cmexpander) {};
+  GlobalFunInfoV(GlobalFunInfo_sp info) : _cmexpander(info->cmexpander()) {};
+  T_sp _cmexpander;
+  T_sp cmexpander() const { return _cmexpander; }
+};
+
 FORWARD(LocalFunInfo);
 class LocalFunInfo_O : public FunInfo_O {
   LISP_CLASS(comp, CompPkg, LocalFunInfo_O, "LocalFunInfo", FunInfo_O);
@@ -147,6 +190,12 @@ class LocalFunInfo_O : public FunInfo_O {
   CL_DEFMETHOD T_sp funVar() const { return this->fun_var; }
 };
 
+struct LocalFunInfoV {
+  LocalFunInfoV(LocalFunInfo_sp info) : _info(info) {};
+  LocalFunInfo_sp _info;
+  LocalFunInfo_sp info() const { return _info; }
+};
+
 // We have separate global and local macro classes because it is sometimes
 // important to know that a binding is local - for example, a local binding
 // shadows a global setf expander.
@@ -167,6 +216,13 @@ class GlobalMacroInfo_O : public FunInfo_O {
   CL_DEFMETHOD Function_sp expander() const { return this->_expander; }
 };
 
+struct GlobalMacroInfoV {
+  GlobalMacroInfoV(Function_sp expander) : _expander(expander) {};
+  GlobalMacroInfoV(GlobalMacroInfo_sp info) : _expander(info->expander()) {};
+  Function_sp _expander;
+  Function_sp expander() const { return _expander; }
+};
+
 FORWARD(LocalMacroInfo);
 class LocalMacroInfo_O : public FunInfo_O {
   LISP_CLASS(comp, CompPkg, LocalMacroInfo_O, "LocalMacroInfo", FunInfo_O);
@@ -183,8 +239,19 @@ class LocalMacroInfo_O : public FunInfo_O {
   CL_DEFMETHOD Function_sp expander() const { return this->_expander; }
 };
 
+struct LocalMacroInfoV {
+  LocalMacroInfoV(Function_sp expander) : _expander(expander) {};
+  LocalMacroInfoV(LocalMacroInfo_sp info) : _expander(info->expander()) {};
+  Function_sp _expander;
+  Function_sp expander() const { return _expander; }
+};
+
+struct NoFunInfoV {};
+
+typedef std::variant<NoFunInfoV, GlobalFunInfoV, LocalFunInfoV, GlobalMacroInfoV, LocalMacroInfoV> FunInfoV;
+
 FORWARD(Lexenv);
-FORWARD(Context);
+class Context; // forward decl
 class Lexenv_O : public General_O {
   LISP_CLASS(comp, CompPkg, Lexenv_O, "Lexenv", General_O);
 public:
@@ -219,7 +286,9 @@ class Lexenv_O : public General_O {
    * environment. The max local count in the current function is also
    * updated.
    */
-  CL_DEFMETHOD Lexenv_sp bind_vars(List_sp vars, Context_sp context);
+  Lexenv_sp bind_vars(List_sp vars, const Context context);
+  // Ditto but with just one.
+  Lexenv_sp bind1var(Symbol_sp var, const Context context);
   // Add VARS as special in ENV.
   CL_DEFMETHOD Lexenv_sp add_specials(List_sp vars);
   // Add FUNCTION NAMES as notinline in ENV.
@@ -246,74 +315,67 @@ class Lexenv_O : public General_O {
 
 // Context contains information about what the current form needs
 // to know about what it is enclosed by.
+// Because they are only ever passed "down" and used within the
+// compiler, they are POD rather than Lisp objects, to save some time
+// on consing and GC.
+// (Profiling has shown that the compiler spends a lot of time consing.)
 FORWARD(Label);
 FORWARD(Cfunction);
 FORWARD(Module);
-class Context_O : public General_O {
-  LISP_CLASS(comp, CompPkg, Context_O, "Context", General_O);
+class Context {
 public:
-  T_sp _receiving;
+  int _receiving;
   List_sp _dynenv;
   T_sp _cfunction;
 public:
-  Context_O(T_sp receiving, T_sp dynenv, T_sp cfunction)
+  Context(int receiving, T_sp dynenv, T_sp cfunction)
     : _receiving(receiving), _dynenv(dynenv), _cfunction(cfunction) {}
-  CL_LISPIFY_NAME(Context/make)
-  CL_DEF_CLASS_METHOD
-  static Context_sp make(T_sp receiving, T_sp dynenv, T_sp cfunction) {
-    return gctools::GC<Context_O>::allocate<gctools::RuntimeStage>(receiving, dynenv, cfunction);
-  }
-  CL_LISPIFY_NAME(context/receiving)
-  CL_DEFMETHOD T_sp receiving() { return this->_receiving; }
-  CL_LISPIFY_NAME(context/dynenv)
-  CL_DEFMETHOD List_sp dynenv() { return this->_dynenv; }
-  CL_DEFMETHOD Cfunction_sp cfunction() {
+  // Sub constructors
+  Context(const Context& parent, int receiving)
+    : _receiving(receiving), _dynenv(parent.dynenv()),
+      _cfunction(parent.cfunction()) {}
+  // Plop the de on the front.
+  Context(const Context& parent, T_sp de)
+    : _receiving(parent.receiving()),
+      _dynenv(Cons_O::create(de, parent.dynenv())),
+      _cfunction(parent.cfunction()) {}
+  int receiving() const { return this->_receiving; }
+  List_sp dynenv() const { return this->_dynenv; }
+  Cfunction_sp cfunction() const {
     return gc::As<Cfunction_sp>(this->_cfunction);
   }
-  CL_DEFMETHOD Module_sp module();
-public:
-  // Make a new context that's like this one but with a possibly-different
-  // RECEIVING.
-  CL_DEFMETHOD Context_sp sub(T_sp receiving) {
-    return Context_O::make(receiving, this->_dynenv, this->_cfunction);
-  }
-  // Make a new context that's like this one but with the given thing
-  // plopped on the dynenv.
-  CL_DEFMETHOD Context_sp subde(T_sp de) {
-    return Context_O::make(this->_receiving, Cons_O::create(de, this->_dynenv),
-                           this->_cfunction);
-  }
-  CL_DEFMETHOD size_t literal_index(T_sp literal);
-  CL_DEFMETHOD size_t new_literal_index(T_sp literal);
-  CL_DEFMETHOD size_t closure_index(T_sp info);
-  CL_DEFMETHOD void assemble0(uint8_t opcode);
-  CL_DEFMETHOD void assemble1(uint8_t opcode, size_t operand1);
-  CL_DEFMETHOD void assemble2(uint8_t opcode,
-                              size_t operand1, size_t operand2);
+  Module_sp module() const;
+public:
+  size_t literal_index(T_sp literal) const;
+  size_t new_literal_index(T_sp literal) const;
+  size_t closure_index(T_sp info) const;
+  void assemble0(uint8_t opcode) const;
+  void assemble1(uint8_t opcode, size_t operand1) const;
+  void assemble2(uint8_t opcode, size_t operand1, size_t operand2) const;
   void emit_control_label(Label_sp,
-                          uint8_t opcode8, uint8_t opcode16, uint8_t opcode24);
-  CL_DEFMETHOD void emit_jump(Label_sp label);
-  CL_DEFMETHOD void emit_jump_if(Label_sp label);
-  CL_DEFMETHOD void emit_entry_or_save_sp(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void emit_ref_or_restore_sp(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void emit_exit(Label_sp label);
-  CL_DEFMETHOD void emit_exit_or_jump(LexicalVarInfo_sp info, Label_sp label);
-  CL_DEFMETHOD void maybe_emit_entry_close(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void emit_catch(Label_sp label);
-  CL_DEFMETHOD void emit_jump_if_supplied(Label_sp label, size_t indx);
-  CL_DEFMETHOD void reference_lexical_info(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void maybe_emit_make_cell(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void maybe_emit_cell_ref(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void maybe_emit_encage(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void emit_lexical_set(LexicalVarInfo_sp info);
-  CL_DEFMETHOD void emit_parse_key_args(size_t max_count, size_t key_count,
-                                        size_t key_start, size_t indx,
-                                        bool aokp);
-  CL_DEFMETHOD void emit_bind(size_t count, size_t offset);
-  CL_DEFMETHOD void emit_call(size_t argcount);
-  CL_DEFMETHOD void emit_mv_call();
-  CL_DEFMETHOD void emit_special_bind(Symbol_sp sym);
-  CL_DEFMETHOD void emit_unbind(size_t count);
+                          uint8_t opcode8, uint8_t opcode16, uint8_t opcode24) const;
+  void emit_jump(Label_sp label) const;
+  void emit_jump_if(Label_sp label) const;
+  void emit_entry_or_save_sp(LexicalVarInfo_sp info) const;
+  void emit_ref_or_restore_sp(LexicalVarInfo_sp info) const;
+  void emit_exit(Label_sp label) const;
+  void emit_exit_or_jump(LexicalVarInfo_sp info, Label_sp label) const;
+  void maybe_emit_entry_close(LexicalVarInfo_sp info) const;
+  void emit_catch(Label_sp label) const;
+  void emit_jump_if_supplied(Label_sp label, size_t indx) const;
+  void reference_lexical_info(LexicalVarInfo_sp info) const;
+  void maybe_emit_make_cell(LexicalVarInfo_sp info) const;
+  void maybe_emit_cell_ref(LexicalVarInfo_sp info) const;
+  void maybe_emit_encage(LexicalVarInfo_sp info) const;
+  void emit_lexical_set(LexicalVarInfo_sp info) const;
+  void emit_parse_key_args(size_t max_count, size_t key_count,
+                           size_t key_start, size_t indx,
+                           bool aokp) const;
+  void emit_bind(size_t count, size_t offset) const;
+  void emit_call(size_t argcount) const;
+  void emit_mv_call() const;
+  void emit_special_bind(Symbol_sp sym) const;
+  void emit_unbind(size_t count) const;
 };
 
 FORWARD(Annotation);
@@ -374,7 +436,7 @@ class Label_O : public Annotation_O {
     return gctools::GC<Label_O>::allocate<gctools::RuntimeStage>();
   }
 public:
-  CL_DEFMETHOD void contextualize(Context_sp context);
+  void contextualize(const Context context);
 };
 
 FORWARD(Fixup);
@@ -399,7 +461,7 @@ class Fixup_O : public Annotation_O {
 public:
   // Mark the fixup in the instruction stream during assembly.
   // FIXME: This name sucks, but emit_fixup seems wayy too confusing.
-  CL_DEFMETHOD void contextualize(Context_sp context);
+  void contextualize(const Context context);
   // Compute the final size (in bytes) for the fixed up code.
   CL_DEFMETHOD virtual size_t resize() = 0;
   // Emit the final code into the bytecode vector.

include/clasp/core/exceptions.h

@@ -261,7 +261,8 @@ void throwTooFewArgumentsError(core::T_sp closure,size_t given, size_t required)
 
 void throwTooManyArgumentsError(core::T_sp closure, size_t given, size_t required);
 
-void throwUnrecognizedKeywordArgumentError(core::T_sp closure, T_sp kw);
+void throwOddKeywordsError(core::T_sp closure);
+void throwUnrecognizedKeywordArgumentError(core::T_sp closure, core::T_sp kw);
 
 void wrongNumberOfArguments(core::T_sp closure, size_t givenNumberOfArguments, size_t requiredNumberOfArguments);
 

include/clasp/core/multipleValues.h

@@ -402,18 +402,23 @@ namespace core {
   * FIXME: Formalize with a macro or templates or something? */
  inline void returnTypeSaveToTemp(size_t nvals, T_O* primary, T_O** temp) {
    if (nvals > 0) { // don't store even the primary unless the space actually exists
-     core::MultipleValues& mv = core::lisp_multipleValues();
      temp[0] = primary;
-     for (size_t i = 1; i < nvals; ++i) {
-       temp[i] = mv._Values[i];
+     if (nvals > 1) {
+       // Only grab this when we really have to - thread local variable
+       // access is pretty expensive.
+       core::MultipleValues& mv = core::lisp_multipleValues();
+       for (size_t i = 1; i < nvals; ++i)
+         temp[i] = mv._Values[i];
      }
    }
  }
  // Build and return a return_type from a temporary vector. See above.
  inline gctools::return_type returnTypeLoadFromTemp(size_t nvals, T_O** temp) {
-   core::MultipleValues& mv = core::lisp_multipleValues();
-   for (size_t i = 1; i < nvals; ++i) {
-     mv._Values[i] = temp[i];
+   if (nvals > 1) {
+     core::MultipleValues& mv = core::lisp_multipleValues();
+     for (size_t i = 1; i < nvals; ++i) {
+       mv._Values[i] = temp[i];
+     }
    }
    return gctools::return_type(nvals == 0 ? nil<core::T_O>().raw_() : temp[0], nvals);
  }

src/analysis/clasp_gc.sif

@@ -23,7 +23,7 @@
                           "llvmo::UndefValue_O" "llvmo::CallBase_O" "core::Path_O"
                           "mp::SharedMutex_O" "asttooling::DerivableASTFrontendAction"
                           "core::InstanceCreator_O" "core::IOStreamStream_O" "core::Scope_O"
-                          "comp::Context_O" "llvmo::InsertPoint_O" "core::FunctionDescription_O"
+                          "llvmo::InsertPoint_O" "core::FunctionDescription_O"
                           "core::ComplexVector_double_O" "core::StrWNs_O" "core::UnknownDynEnv_O"
                           "core::EchoStream_O" "core::HashTableBase_O" "core::SimpleMDArrayBit_O"
                           "core::MDArrayBit_O" "core::ComplexVector_byte16_t_O"
@@ -4752,18 +4752,6 @@
 {class-kind :stamp-name "STAMPWTAG_llvmo__InsertPoint_O" :stamp-key "llvmo::InsertPoint_O"
             :parent-class "core::General_O" :lisp-class-base "core::General_O"
             :root-class "core::T_O" :stamp-wtag 3 :definition-data "IS_POLYMORPHIC"}
-{class-kind :stamp-name "STAMPWTAG_comp__Context_O" :stamp-key "comp::Context_O"
-            :parent-class "core::General_O" :lisp-class-base "core::General_O"
-            :root-class "core::T_O" :stamp-wtag 3 :definition-data "IS_POLYMORPHIC"}
-{fixed-field :offset-type-cxx-identifier "SMART_PTR_OFFSET"
-             :offset-ctype "gctools::smart_ptr<core::T_O>" :offset-base-ctype "comp::Context_O"
-             :layout-offset-field-names ("_receiving")}
-{fixed-field :offset-type-cxx-identifier "SMART_PTR_OFFSET"
-             :offset-ctype "gctools::smart_ptr<core::List_V>" :offset-base-ctype "comp::Context_O"
-             :layout-offset-field-names ("_dynenv")}
-{fixed-field :offset-type-cxx-identifier "SMART_PTR_OFFSET"
-             :offset-ctype "gctools::smart_ptr<core::T_O>" :offset-base-ctype "comp::Context_O"
-             :layout-offset-field-names ("_cfunction")}
 {class-kind :stamp-name "STAMPWTAG_core__Scope_O" :stamp-key "core::Scope_O"
             :parent-class "core::General_O" :lisp-class-base "core::General_O"
             :root-class "core::T_O" :stamp-wtag 3 :definition-data "IS_POLYMORPHIC"}