Merge pull request #1575 from clasp-developers/fasl-native

Fasl native (preliminaries)

Author: Bike

include/clasp/core/bytecode.h

@@ -24,53 +24,52 @@ class BytecodeModule_O : public core::CxxObject_O {
   LISP_CLASS(core, CorePkg, BytecodeModule_O, "BytecodeModule", core::CxxObject_O);
 
 public:
-  void initialize();
-
-public:
-  typedef T_O Literals_O_Type;
-  typedef T_O Bytecode_O_Type;
-  typedef T_sp Literals_sp_Type;
-  typedef T_sp Bytecode_sp_Type;
-
-public:
-  Literals_sp_Type _Literals;
-  Bytecode_sp_Type _Bytecode;
-  // A simple-vector of BytecodeDebugInfo_sp (below)
-  // ordered by start index
-  T_sp _DebugInfo = nil<T_O>();
+  // The actual bytecode.
+  SimpleVector_byte8_t_sp _Bytecode;
+  // A simple vector of literal objects referred to by the bytecode.
+  // During loadltv, this will be default-initialized for a bit, hence
+  // why it's not a SimpleVector_sp.
+  T_sp _Literals = nil<T_O>();
   // A list of literal indices.
   // This indicates the constant at that index is a mutable
   // load-time-value (i.e. from (load-time-value foo [nil]))
   // which is important to know for BTB compilation.
   // Some kind of bit vector could be used instead, but it's
   // expected that these load time values will be rare.
   T_sp _MutableLiterals = nil<T_O>();
+  // A simple-vector of BytecodeDebugInfo_sp (below)
+  // ordered by start index
+  T_sp _DebugInfo = nil<T_O>();
+  // If this bytecode has been native-compiled, this can be
+  // the corresponding JITDylib_sp.
+  T_sp _NativeModule = nil<T_O>();
 
 public:
-  BytecodeModule_O(){};
+  BytecodeModule_O(SimpleVector_byte8_t_sp bytecode)
+    : _Bytecode(bytecode) {};
   CL_LISPIFY_NAME(BytecodeModule/make)
   CL_DEF_CLASS_METHOD
-  static BytecodeModule_sp make() {
+  static BytecodeModule_sp make(SimpleVector_byte8_t_sp bytecode) {
     // When we can gc code allocate entire block in GC memory
-    BytecodeModule_sp codeblock = gctools::GC<BytecodeModule_O>::allocate<gctools::RuntimeStage>();
+    BytecodeModule_sp codeblock = gctools::GC<BytecodeModule_O>::allocate<gctools::RuntimeStage>(bytecode);
     // Register the new module for the debugger
     codeblock->register_for_debug();
     return codeblock;
   };
 
-  Literals_sp_Type literals() const;
-  void setf_literals(T_sp obj);
-  Bytecode_sp_Type bytecode() const;
-  void setf_bytecode(T_sp obj);
-  Bytecode_sp_Type compileInfo() const;
-  void setf_compileInfo(T_sp obj);
+  CL_DEFMETHOD T_sp literals() const { return this->_Literals; }
+  CL_DEFMETHOD void setf_literals(SimpleVector_sp obj) { this->_Literals = obj; }
+  CL_DEFMETHOD SimpleVector_byte8_t_sp bytecode() const { return this->_Bytecode; }
   CL_LISPIFY_NAME(BytecodeModule/debugInfo)
   CL_DEFMETHOD T_sp debugInfo() const { return this->_DebugInfo; }
   CL_LISPIFY_NAME(BytecodeModule/setfDebugInfo)
   CL_DEFMETHOD void setf_debugInfo(T_sp info) { this->_DebugInfo = info; }
   CL_LISPIFY_NAME(BytecodeModule/mutableLiterals)
   CL_DEFMETHOD T_sp mutableLiterals() const { return this->_MutableLiterals; }
   void setf_mutableLiterals(T_sp indices) { this->_MutableLiterals = indices; }
+  CL_LISPIFY_NAME(BytecodeModule/nativeModule)
+  CL_DEFMETHOD T_sp nativeModule() const { return this->_NativeModule; }
+  void setf_nativeModule(T_sp mod) { this->_NativeModule = mod; }
 
   // Add the module to *all-bytecode-modules* for the debugger.
   void register_for_debug();

include/clasp/core/bytecode_compiler.h

@@ -635,18 +635,18 @@ class JumpIfSuppliedFixup_O : public LabelFixup_O {
   LISP_CLASS(comp, CompPkg, JumpIfSuppliedFixup_O, "JumpIfSuppliedFixup", LabelFixup_O);
 
 public:
-  uint8_t _index;
+  uint16_t _index;
 
 public:
-  JumpIfSuppliedFixup_O(Label_sp label, uint8_t index) : LabelFixup_O(label, 3), _index(index) {}
+  JumpIfSuppliedFixup_O(Label_sp label, uint16_t index) : LabelFixup_O(label, 3), _index(index) {}
   CL_LISPIFY_NAME(JumpIfSuppliedFixup/make)
   CL_DEF_CLASS_METHOD
-  static JumpIfSuppliedFixup_sp make(Label_sp label, uint8_t nindex) {
+  static JumpIfSuppliedFixup_sp make(Label_sp label, uint16_t nindex) {
     return gctools::GC<JumpIfSuppliedFixup_O>::allocate<gctools::RuntimeStage>(label, nindex);
   }
 
 public:
-  uint8_t iindex() { return this->_index; }
+  uint16_t iindex() { return this->_index; }
   virtual void emit(size_t position, SimpleVector_byte8_t_sp code);
   virtual size_t resize();
 };
@@ -816,6 +816,8 @@ class LoadTimeValueInfo_O : public General_O {
   bool _read_only_p;
 
 public:
+  CL_LISPIFY_NAME(LoadTimeValueInfo/make)
+  CL_DEF_CLASS_METHOD
   static LoadTimeValueInfo_sp make(T_sp form, bool read_only_p) {
     return gctools::GC<LoadTimeValueInfo_O>::allocate<gctools::RuntimeStage>(form, read_only_p);
   }
@@ -843,6 +845,8 @@ class ConstantInfo_O : public General_O {
 public:
   T_sp _value; // the value of the constant.
 public:
+  CL_LISPIFY_NAME(ConstantInfo/make)
+  CL_DEF_CLASS_METHOD
   static ConstantInfo_sp make(T_sp value) { return gctools::GC<ConstantInfo_O>::allocate<gctools::RuntimeStage>(value); }
 
 public:
@@ -863,6 +867,8 @@ class FunctionCellInfo_O : public General_O {
 public:
   T_sp _fname; // Name of the function being looked up.
 public:
+  CL_LISPIFY_NAME(FunctionCellInfo/make)
+  CL_DEF_CLASS_METHOD
   static FunctionCellInfo_sp make(T_sp fname) { return gctools::GC<FunctionCellInfo_O>::allocate<gctools::RuntimeStage>(fname); }
 
 public:
@@ -881,6 +887,8 @@ class VariableCellInfo_O : public General_O {
 public:
   Symbol_sp _vname; // Name of the variable being looked up.
 public:
+  CL_LISPIFY_NAME(VariableCellInfo/make)
+  CL_DEF_CLASS_METHOD
   static VariableCellInfo_sp make(Symbol_sp vname) {
     return gctools::GC<VariableCellInfo_O>::allocate<gctools::RuntimeStage>(vname);
   }
@@ -898,6 +906,8 @@ class EnvInfo_O : public General_O {
 public:
   EnvInfo_O() {}
 public:
+  CL_LISPIFY_NAME(EnvInfo/make)
+  CL_DEF_CLASS_METHOD
   static EnvInfo_sp make() {
     return gctools::GC<EnvInfo_O>::allocate<gctools::RuntimeStage>();
   }
@@ -1000,59 +1010,64 @@ class Cfunction_O : public General_O {
   }
   CL_DEFMETHOD Module_sp module() { return _module; }
   CL_LISPIFY_NAME(cfunction/bytecode)
-  CL_DEFMETHOD ComplexVector_byte8_t_sp bytecode() { return _bytecode; }
-  CL_DEFMETHOD ComplexVector_T_sp annotations() { return _annotations; }
+  CL_DEFMETHOD ComplexVector_byte8_t_sp bytecode() const { return _bytecode; }
+  CL_DEFMETHOD ComplexVector_T_sp annotations() const { return _annotations; }
   CL_LISPIFY_NAME(cfunction/debug-info)
-  CL_DEFMETHOD ComplexVector_T_sp debug_info() { return _debug_info; }
-  CL_DEFMETHOD size_t nlocals() { return _nlocals; }
+  CL_DEFMETHOD ComplexVector_T_sp debug_info() const { return _debug_info; }
+  CL_DEFMETHOD size_t nlocals() const { return _nlocals; }
   CL_LISPIFY_NAME(Cfunction/setf-nlocals)
   CL_DEFMETHOD size_t setNlocals(size_t new_nlocals) {
     this->_nlocals = new_nlocals;
     return new_nlocals;
   }
-  CL_DEFMETHOD ComplexVector_T_sp closed() { return _closed; }
+  CL_DEFMETHOD ComplexVector_T_sp closed() const { return _closed; }
   CL_LISPIFY_NAME(Cfunction/entry-point)
-  CL_DEFMETHOD Label_sp entry_point() { return _entry_point; }
+  CL_DEFMETHOD Label_sp entry_point() const { return _entry_point; }
   CL_LISPIFY_NAME(Cfunction/position)
-  CL_DEFMETHOD size_t pposition() { return _position; }
+  CL_DEFMETHOD size_t pposition() const { return _position; }
   CL_LISPIFY_NAME(Cfunction/setf-position)
   CL_DEFMETHOD size_t setPosition(size_t npos) {
     this->_position = npos;
     return npos;
   }
-  CL_DEFMETHOD size_t extra() { return _extra; }
+  CL_DEFMETHOD size_t extra() const { return _extra; }
   CL_LISPIFY_NAME(Cfunction/setf-extra)
   CL_LAMBDA(cfunction new) // avoid name conflict with next
   CL_DEFMETHOD size_t setExtra(size_t next) {
     this->_extra = next;
     return next;
   }
   CL_LISPIFY_NAME(Cfunction/final_size)
-  CL_DEFMETHOD size_t final_size() { return this->bytecode()->length() + this->extra(); }
+  CL_DEFMETHOD size_t final_size() const { return this->bytecode()->length() + this->extra(); }
   CL_LISPIFY_NAME(Cfunction/index)
-  CL_DEFMETHOD size_t iindex() { return _index; }
+  CL_DEFMETHOD size_t iindex() const { return _index; }
   CL_LISPIFY_NAME(Cfunction/setf-index)
   CL_DEFMETHOD size_t setIndex(size_t nindex) {
     this->_index = nindex;
     return nindex;
   }
-  CL_DEFMETHOD BytecodeSimpleFun_sp info() { return _info; }
+  CL_DEFMETHOD BytecodeSimpleFun_sp info() const { return _info; }
   CL_LISPIFY_NAME(Cfunction/setf-info)
   CL_DEFMETHOD BytecodeSimpleFun_sp setInfo(BytecodeSimpleFun_sp gbep) {
     this->_info = gbep;
     return gbep;
   }
   CL_LISPIFY_NAME(Cfunction/name)
-  CL_DEFMETHOD T_sp nname() { return _name; }
-  CL_DEFMETHOD T_sp doc() { return _doc; }
+  CL_DEFMETHOD T_sp nname() const { return _name; }
+  CL_DEFMETHOD T_sp doc() const { return _doc; }
   CL_LISPIFY_NAME(Cfunction/lambda-list)
-  CL_DEFMETHOD T_sp lambda_list() { return _lambda_list; }
-  T_sp sourcePosInfo() { return _source_pos_info; }
+  CL_DEFMETHOD T_sp lambda_list() const { return _lambda_list; }
+  CL_LISPIFY_NAME(Cfunction/source-pos-info)
+  CL_DEFMETHOD T_sp sourcePosInfo() const { return _source_pos_info; }
 
 public:
   // Convenience method to link the module and return the new bytecode function
   // corresponding to this cfunction. Good for cl:compile.
   CL_DEFMETHOD Function_sp link_function();
+public:
+  // For use as a BytecodeDebugInfo.
+  T_sp start() const;
+  T_sp end() const;
 };
 
 // Main entry point

include/clasp/core/function.h

@@ -334,6 +334,7 @@ class SimpleCoreFun_O : public SimpleFun_O {
 public:
   // Accessors
   SimpleCoreFun_O(FunctionDescription_sp fdesc, const ClaspXepTemplate& entry_point, T_sp code, CoreFun_sp localFun);
+  static SimpleCoreFun_sp make(FunctionDescription_sp fdesc, ClaspCoreFunction main, ClaspXepAnonymousFunction* xep);
 
 public:
   virtual Pointer_sp defaultEntryAddress() const;

include/clasp/llvmo/code.h

@@ -93,7 +93,6 @@ class ObjectFile_O : public LibraryBase_O {
   size_t _FasoIndex;
   //
   // Code data
-  gctools::GCRootsInModule* _gcRoots;
   void* _TextSectionStart;
   void* _TextSectionEnd;
   uintptr_t _TextSectionId;
@@ -109,16 +108,16 @@ class ObjectFile_O : public LibraryBase_O {
   ObjectFile_O(core::SimpleBaseString_sp codename, std::unique_ptr<llvm::MemoryBuffer> buffer, size_t objectId,
                JITDylib_sp jitdylib, core::SimpleBaseString_sp fasoName, size_t fasoIndex)
       : _State(RunState), _CodeName(codename), _MemoryBuffer(std::move(buffer)), _ObjectId(objectId), _TheJITDylib(jitdylib),
-        _FasoName(fasoName), _FasoIndex(fasoIndex), _gcRoots(NULL), _CodeBlock(unbound<CodeBlock_O>()) {
+        _FasoName(fasoName), _FasoIndex(fasoIndex), _CodeBlock(unbound<CodeBlock_O>()) {
     DEBUG_OBJECT_FILES_PRINT(("%s:%d:%s   objectId = %lu\n", __FILE__, __LINE__, __FUNCTION__, objectId));
   };
   ObjectFile_O(core::SimpleBaseString_sp codename, JITDylib_sp jitdylib, size_t objectId)
-      : _State(RunState), _CodeName(codename), _ObjectId(objectId), _TheJITDylib(jitdylib), _gcRoots(NULL),
+      : _State(RunState), _CodeName(codename), _ObjectId(objectId), _TheJITDylib(jitdylib),
         _CodeBlock(unbound<CodeBlock_O>()) {
     DEBUG_OBJECT_FILES_PRINT(("%s:%d:%s   codename = %s\n", __FILE__, __LINE__, __FUNCTION__, _rep_(codename).c_str()));
   };
   ObjectFile_O(core::SimpleBaseString_sp codename, CodeBlock_sp codeBlock, JITDylib_sp dylib, size_t objectId)
-      : _State(RunState), _CodeName(codename), _ObjectId(objectId), _TheJITDylib(dylib), _gcRoots(NULL), _TextSectionStart(0),
+      : _State(RunState), _CodeName(codename), _ObjectId(objectId), _TheJITDylib(dylib), _TextSectionStart(0),
         _TextSectionEnd(0), _CodeBlock(codeBlock) {
     DEBUG_OBJECT_FILES_PRINT(("%s:%d:%s created with CodeBlock_sp   codename = %s CodeBlock = %s\n", __FILE__, __LINE__,
                               __FUNCTION__, _rep_(codename).c_str(), core::_rep_(codeBlock).c_str()));