#include <clang_compiler.hpp>

Detailed Description

Author: Joris Gillis

Date: 2015

Interface to the JIT compiler CLANG

Extra doc: https://github.com/casadi/casadi/wiki/L_21v

List of available options
Id	Type	Description
flags	OT_STRINGVECTOR	Compile flags for the JIT compiler. Default: None
include_path	OT_STRING	Include paths for the JIT compiler. The include directory shipped with CasADi will be automatically appended.

List of available options
Id	Type	Description	Used in
flags	OT_STRINGVECTOR	Compile flags for the JIT compiler. Default: None	casadi::ClangCompiler
include_path	OT_STRING	Include paths for the JIT compiler. The include directory shipped with CasADi will be automatically appended.	casadi::ClangCompiler
verbose	OT_BOOL	Verbose evaluation – for debugging	casadi::ImporterInternal

Definition at line 83 of file clang_compiler.hpp.

Inheritance diagram for casadi::ClangCompiler:

[legend]

Collaboration diagram for casadi::ClangCompiler:

[legend]

Public Types
typedef ImporterInternal (	Creator) (const std::string &name)

using	weak_ref_type = WeakRefInternal

typedef int(*	RegFcn) (Plugin *plugin)

Public Member Functions
	ClangCompiler (const std::string &name)
	Constructor. More...

	~ClangCompiler () override
	Destructor. More...

void	init (const Dict &opts) override
	Initialize. More...

const char *	plugin_name () const override
	Get name of plugin. More...

std::string	class_name () const override
	Get type name. More...

signal_t	get_function (const std::string &symname) override
	Get a function pointer for numerical evaluation. More...

void	disp (std::ostream &stream, bool more) const override
	Print. More...

void	construct (const Dict &opts)
	Construct. More...

virtual void	finalize ()

bool	has_function (const std::string &symname) const
	Get a function pointer for numerical evaluation. More...

bool	has_meta (const std::string &cmd, casadi_int ind=-1) const
	Does an entry exist? More...

std::string	get_meta (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	read_meta (std::istream &file, casadi_int &offset)
	Get meta information. More...

void	read_external (const std::string &sym, bool inlined, std::istream &file, casadi_int &offset)
	Get an external function declaration. More...

bool	inlined (const std::string &symname) const

std::string	body (const std::string &symname) const
	Get the function body, if inlined. More...

virtual std::string	library () const
	Get library name. More...

virtual bool	can_have_meta () const
	Can meta information be read? More...

std::string	to_text (const std::string &cmd, casadi_int ind=-1) const
	Get entry as a text. More...

void	serialize (SerializingStream &s) const

virtual void	serialize_type (SerializingStream &s) const

virtual void	serialize_body (SerializingStream &s) const

casadi_int	getCount () const
	Get the reference count. More...

std::string	debug_repr (const SharedObjectInternal *) const

GenericWeakRef< SharedObject, SharedObjectInternal > *	weak ()
	Get a weak reference to the object. More...

virtual void	deps_version_check (const std::string &stage) const

Static Public Member Functions
static ImporterInternal *	creator (const std::string &name)
	Create a new JIT function. More...

static std::vector< std::pair< std::string, bool > >	getIncludes (const std::string &file, const std::string &path)

static std::string	shortname ()
	Short name. More...

static std::string	indexed (const std::string &cmd, casadi_int ind)

static ImporterInternal *	deserialize (DeserializingStream &s)

static bool	has_plugin (const std::string &pname, bool verbose=false)
	Check if a plugin is available or can be loaded. More...

static const Options &	plugin_options (const std::string &pname)
	Get the plugin options. More...

static Deserialize	plugin_deserialize (const std::string &pname)
	Get the plugin deserialize_map. More...

static Plugin	pluginFromRegFcn (RegFcn regfcn)
	Instantiate a Plugin struct from a factory function. More...

static Plugin	load_plugin (const std::string &pname, bool register_plugin=true, bool needs_lock=true)
	Load a plugin dynamically. More...

static handle_t	load_library (const std::string &libname, std::string &resultpath, bool global)
	Load a library dynamically. More...

static void	registerPlugin (const Plugin &plugin, bool needs_lock=true)
	Register an integrator in the factory. More...

static void	registerPlugin (RegFcn regfcn, bool needs_lock=true)
	Register an integrator in the factory. More...

static Plugin &	getPlugin (const std::string &pname)
	Load and get the creator function. More...

static ImporterInternal *	instantiate (const std::string &fname, const std::string &pname, Problem problem)

Public Attributes
std::string	include_path_

std::vector< std::string >	flags_

std::string	name_
	C filename. More...

std::map< std::string, std::pair< casadi_int, std::string > >	meta_
	Meta data. More...

std::map< std::string, std::pair< bool, std::string > >	external_
	External functions. More...

bool	verbose_
	Verbose – for debugging purposes. More...

Static Public Attributes
static const std::string	meta_doc
	A documentation string. More...

static std::map< std::string, Plugin >	solvers_
	Collection of solvers. More...

static const std::string	infix_ = "importer"
	Infix. More...

Protected Member Functions
void	initSingleton ()

void	destroySingleton ()

B	shared_from_this ()
	Get a shared object from the current internal object. More...

const B	shared_from_this () const
	Get a shared object from the current internal object. More...

Protected Attributes
clang::EmitLLVMOnlyAction *	act_

llvm::ExecutionEngine *	executionEngine_

llvm::LLVMContext *	context_

llvm::raw_ostream *	myerr_

llvm::Module *	module_

static const Options	options_
	Options. More...

const Options &	get_options () const override
	Options. More...

Member Typedef Documentation

◆ Creator

typedef ImporterInternal*(* casadi::ImporterInternal::Creator) (const std::string &name)

inherited

Definition at line 66 of file importer_internal.hpp.

◆ RegFcn

typedef int(* casadi::PluginInterface< ImporterInternal >::RegFcn) (Plugin *plugin)

inherited

Definition at line 73 of file plugin_interface.hpp.

◆ weak_ref_type

using casadi::SharedObjectInternal::weak_ref_type = WeakRefInternal

inherited

Definition at line 152 of file shared_object.hpp.

Constructor & Destructor Documentation

◆ ClangCompiler()

casadi::ClangCompiler::ClangCompiler ( const std::string & name )

explicit

Definition at line 60 of file clang_compiler.cpp.

                                                     :
     ImporterInternal(name) {
  
     myerr_ = nullptr;
     executionEngine_ = nullptr;
     context_ = nullptr;
     act_ = nullptr;
   }

References act_, context_, executionEngine_, and myerr_.

◆ ~ClangCompiler()

casadi::ClangCompiler::~ClangCompiler ( )

override

Definition at line 69 of file clang_compiler.cpp.

                                 {
     if (act_) delete act_; // NOLINT(readability-delete-null-pointer)
     if (myerr_) delete myerr_; // NOLINT(readability-delete-null-pointer)
     if (executionEngine_) delete executionEngine_; // NOLINT(readability-delete-null-pointer)
     if (context_) delete context_; // NOLINT(readability-delete-null-pointer)
   }

References act_, context_, executionEngine_, and myerr_.

Member Function Documentation

◆ body()

std::string casadi::ImporterInternal::body ( const std::string & symname ) const

inherited

Definition at line 306 of file importer_internal.cpp.

                                                                  {
     auto it = external_.find(symname);
     casadi_assert_dev(it!=external_.end() && it->second.first);
     return it->second.second;
   }

References casadi::ImporterInternal::external_.

◆ can_have_meta()

virtual bool casadi::ImporterInternal::can_have_meta ( ) const

inlinevirtualinherited

Reimplemented in casadi::DllLibrary.

Definition at line 142 of file importer_internal.hpp.

142 { return true;}

Referenced by casadi::ImporterInternal::init().

◆ class_name()

std::string casadi::ClangCompiler::class_name ( ) const

inlineoverridevirtual

Extra doc: https://github.com/casadi/casadi/wiki/L_219

Reimplemented from casadi::ImporterInternal.

Definition at line 113 of file clang_compiler.hpp.

113 { return "ClangCompiler";}

◆ construct()

void casadi::ImporterInternal::construct ( const Dict & opts )

inherited

Prepares the function for evaluation

Extra doc: https://github.com/casadi/casadi/wiki/L_21b

Definition at line 57 of file importer_internal.cpp.

                                                    {
     // Sanitize dictionary is needed
     if (!Options::is_sane(opts)) {
       // Call recursively
       construct(Options::sanitize(opts));
       return;
     }
  
     // Make sure all options exist
     get_options().check(opts);
  
     // Initialize object
     init(opts);
  
     // Revisit class hierarchy in reverse order
     finalize();
   }

References casadi::Options::check(), casadi::ImporterInternal::finalize(), casadi::ImporterInternal::get_options(), casadi::ImporterInternal::init(), casadi::Options::is_sane(), and casadi::Options::sanitize().

Referenced by casadi::Importer::create().

◆ creator()

static ImporterInternal* casadi::ClangCompiler::creator ( const std::string & name )

inlinestatic

Definition at line 90 of file clang_compiler.hpp.

                                                             {
       return new ClangCompiler(name);
     }

Referenced by casadi::casadi_register_importer_clang().

◆ debug_repr()

std::string casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::debug_repr ( const Internal * i ) const

inherited

Definition at line 62 of file generic_shared_internal.hpp.

                                                                                        {
     // Note: i != this because of something something multiple inheritance
     return str( (casadi_int)(i)) + "/" + static_cast<const Internal*>(this)->class_name();
   }

◆ deps_version_check()

virtual void casadi::PluginInterface< ImporterInternal >::deps_version_check ( const std::string & stage ) const

inlinevirtualinherited

Definition at line 112 of file plugin_interface.hpp.

112 {}

◆ deserialize()

ImporterInternal * casadi::ImporterInternal::deserialize ( DeserializingStream & s )

staticinherited

Definition at line 339 of file importer_internal.cpp.

                                                                         {
     std::string class_name;
     s.unpack("ImporterInternal::type", class_name);
     if (class_name=="DllLibrary") {
       return DllLibrary::deserialize(s);
     } else {
        casadi_error("Cannot deserialize type '" + class_name + "'");
     }
   }

References casadi::ImporterInternal::class_name(), casadi::DllLibrary::deserialize(), and casadi::DeserializingStream::unpack().

Referenced by casadi::Importer::deserialize().

◆ destroySingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::destroySingleton ( )

inlineprotectedinherited

Called in the destructor of singletons

Definition at line 77 of file generic_shared_internal.hpp.

                             {
       static_cast<Internal*>(this)->count--;
     }

◆ disp()

void casadi::ImporterInternal::disp	(	std::ostream &	stream,
		bool	more
	)		const

overridevirtualinherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21a

Implements casadi::SharedObjectInternal.

Definition at line 38 of file importer_internal.cpp.

38 {

39 }

◆ finalize()

virtual void casadi::ImporterInternal::finalize ( )

inlinevirtualinherited

Reimplemented in casadi::DllLibrary.

Definition at line 88 of file importer_internal.hpp.

88 {}

Referenced by casadi::ImporterInternal::construct().

◆ get_function()

signal_t casadi::ClangCompiler::get_function ( const std::string & symname )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 239 of file clang_compiler.cpp.

                                                                {
     llvm::Function* f = module_->getFunction(symname);
     if (f) {
       return reinterpret_cast<signal_t>(executionEngine_->getPointerToFunction(f));
     } else {
       return nullptr;
     }
   }

References executionEngine_, and module_.

◆ get_meta()

std::string casadi::ImporterInternal::get_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21f

Definition at line 290 of file importer_internal.cpp.

                                                                                  {
     if (ind>=0) return get_meta(indexed(cmd, ind));
     casadi_assert(has_meta(cmd), "No such command: " + cmd);
     return meta_.at(cmd).second;
   }

References casadi::ImporterInternal::has_meta(), casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

◆ get_options()

const Options& casadi::ClangCompiler::get_options ( ) const

inlineoverridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 100 of file clang_compiler.hpp.

100 { return options_;}

casadi::ClangCompiler::options_

static const Options options_

Options.

Definition: clang_compiler.hpp:99

◆ getCount()

casadi_int casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::getCount

inherited

Definition at line 60 of file generic_shared_internal.hpp.

                                                                      {
     return static_cast<const Internal*>(this)->count;
   }

◆ getIncludes()

std::vector< std::pair< std::string, bool > > casadi::ClangCompiler::getIncludes	(	const std::string &	file,
		const std::string &	path
	)

static

Definition at line 248 of file clang_compiler.cpp.

                                                             {
     // File separator
 #ifdef _WIN32
     const char sep = '\\';
 #else // _WIN32
     const char sep = '/';
 #endif // _WIN32
  
     // Return value
     std::vector<std::pair<std::string, bool> > ret;
  
     // Read line-by-line
     auto setup_file_ptr = Filesystem::ifstream_ptr(path + sep + file);
     std::istream& setup_file = *setup_file_ptr;
  
     std::string line;
     while (std::getline(setup_file, line)) {
       // Skip empty lines
       if (line.empty()) continue;
  
       // Check if framework
       size_t loc = line.find(" (framework directory)");
       bool isframework = loc != std::string::npos;
       if (isframework) {
         // Truncate path
         line = line.substr(0, loc);
       }
  
       // Check if the path is absolute or relative
 #ifdef _WIN32
       bool relative = PathIsRelative(TEXT(line.c_str()));
 #else // _WIN32
       bool relative = line.at(0)!=sep;
 #endif // _WIN32
  
       if (relative) {
         // Relative path, make absolute
         ret.push_back(std::make_pair(path + sep + line, isframework));
       } else {
         // Absolute path
         ret.push_back(std::make_pair(line, isframework));
       }
     }
  
     return ret;
   }

References casadi::Filesystem::ifstream_ptr(), and casadi::path().

Referenced by init().

◆ getPlugin()

PluginInterface< ImporterInternal >::Plugin & casadi::PluginInterface< ImporterInternal >::getPlugin ( const std::string & pname )

staticinherited

Definition at line 102 of file plugin_interface.hpp.

                                                             {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver has been loaded
     auto it=Derived::solvers_.find(pname);
  
     // Load the solver if needed
     if (it==Derived::solvers_.end()) {
       load_plugin(pname, true, false);
       it=Derived::solvers_.find(pname);
     }
     casadi_assert_dev(it!=Derived::solvers_.end());
     return it->second;
   }

◆ has_function()

bool casadi::ImporterInternal::has_function ( const std::string & symname ) const

inherited

Definition at line 217 of file importer_internal.cpp.

                                                                     {
     // Check if in meta information
     if (external_.find(symname)!=external_.end()) return true;
  
     // Convert to a dummy function pointer
     return const_cast<ImporterInternal*>(this)->get_function(symname)!=nullptr;
   }

References casadi::ImporterInternal::external_, and casadi::ImporterInternal::get_function().

◆ has_meta()

bool casadi::ImporterInternal::has_meta	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21e

Definition at line 296 of file importer_internal.cpp.

                                                                             {
     if (ind>=0) return has_meta(indexed(cmd, ind));
     return meta_.find(cmd) != meta_.end();
   }

References casadi::ImporterInternal::indexed(), and casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::get_meta().

◆ has_plugin()

bool casadi::PluginInterface< ImporterInternal >::has_plugin	(	const std::string &	pname,
		bool	verbose = `false`
	)

staticinherited

Definition at line 76 of file plugin_interface.hpp.

                                                                                 {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     std::lock_guard<std::mutex> lock(Derived::mutex_solvers_);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Quick return if available
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       return true;
     }
  
     // Try loading the plugin
     try {
       (void)load_plugin(pname, false, false);
       return true;
     } catch (CasadiException& ex) {
       if (verbose) {
         casadi_warning(ex.what());
       }
       return false;
     }
   }

◆ indexed()

static std::string casadi::ImporterInternal::indexed	(	const std::string &	cmd,
		casadi_int	ind
	)

inlinestaticinherited

Convert indexed command

Definition at line 150 of file importer_internal.hpp.

                                                                           {
       std::stringstream ss;
       ss << cmd << "[" << ind << "]";
       return ss.str();
     }

Referenced by casadi::ImporterInternal::get_meta(), and casadi::ImporterInternal::has_meta().

◆ init()

void casadi::ClangCompiler::init ( const Dict & opts )

overridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 88 of file clang_compiler.cpp.

                                            {
     // Base class
     ImporterInternal::init(opts);
  
     // Read options
     for (auto&& op : opts) {
       if (op.first=="include_path") {
         include_path_ = op.second.to_string();
       } else if (op.first=="flags") {
         flags_ = op.second;
       }
     }
  
     // Arguments to pass to the clang frontend
     std::vector<const char *> args(1, name_.c_str());
     for (auto&& f : flags_) {
       args.push_back(f.c_str());
     }
  
     // Create the compiler instance
     clang::CompilerInstance compInst;
  
     // A symbol in the DLL
     void *addr = reinterpret_cast<void*>(&casadi_register_importer_clang);
  
     // Get runtime include path
     std::string jit_include;
 #ifdef _WIN32
     char buffer[MAX_PATH];
     HMODULE hm = NULL;
     if (!GetModuleHandleExA(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS |
                             GET_MODULE_HANDLE_EX_FLAG_UNCHANGED_REFCOUNT,
                             (LPCSTR)addr, &hm)) {
       casadi_error("GetModuleHandle failed");
     }
     GetModuleFileNameA(hm, buffer, sizeof(buffer));
     PathRemoveFileSpecA(buffer);
     jit_include = buffer;
 #else // _WIN32
     Dl_info dl_info;
     if (!dladdr(addr, &dl_info)) {
       casadi_error("dladdr failed");
     }
     jit_include = dl_info.dli_fname;
     jit_include = jit_include.substr(0, jit_include.find_last_of('/'));
 #endif // _WIN32
     jit_include += filesep() + "casadi" + filesep() + "jit";
  
 #if 0
     // Initialize target info with the default triple for our platform.
     auto targetoptions = std::make_shared<clang::Taroptions>();
     targetoptions->Triple = llvm::sys::getDefaultTargetTriple();
     clang::TargetInfo *targetInfo =
       clang::TargetInfo::CreateTargetInfo(compInst.get_diagnostics(), targetoptions);
     compInst.setTarget(targetInfo);
 #endif
  
     // The compiler invocation needs a DiagnosticsEngine so it can report problems
     clang::DiagnosticOptions* diagOpts = new clang::DiagnosticOptions();
     myerr_ = new llvm::raw_os_ostream(uerr());
     clang::TextDiagnosticPrinter *diagClient = new clang::TextDiagnosticPrinter(*myerr_, diagOpts);
  
     clang::DiagnosticIDs* diagID = new clang::DiagnosticIDs();
     // This object takes ownerships of all three passed-in pointers
     clang::DiagnosticsEngine diags(diagID, diagOpts, diagClient);
  
     // Create the compiler invocation
     #if LLVM_VERSION_MAJOR >= 4
     std::shared_ptr<clang::CompilerInvocation> compInv(new clang::CompilerInvocation());
     #else
     clang::CompilerInvocation* compInv = new clang::CompilerInvocation();
     #endif
     #if LLVM_VERSION_MAJOR >= 5
     clang::CompilerInvocation::CreateFromArgs(*compInv, args, diags);
     #else
     clang::CompilerInvocation::CreateFromArgs(*compInv, &args[0],
                                               &args[0] + args.size(), diags);
     #endif
     compInst.setInvocation(compInv);
  
     // Get ready to report problems
     compInst.createDiagnostics();
     if (!compInst.hasDiagnostics())
       casadi_error("Cannot create diagnostics");
  
     // Set resource directory
     std::string resourcedir = jit_include + filesep() + "clang" + filesep() + CLANG_VERSION_STRING;
     compInst.getHeaderSearchOpts().ResourceDir = resourcedir;
  
     // Read the system includes (C or C++)
     std::vector<std::pair<std::string, bool> >
     system_include = getIncludes("system_includes.txt", jit_include);
     for (auto i=system_include.begin(); i!=system_include.end(); ++i) {
       compInst.getHeaderSearchOpts().AddPath(i->first,
                                              clang::frontend::System, i->second, false);
     }
  
     // Read the system includes (C only)
     system_include = getIncludes("csystem_includes.txt", jit_include);
     for (auto i=system_include.begin(); i!=system_include.end(); ++i) {
       compInst.getHeaderSearchOpts().AddPath(i->first,
                                              clang::frontend::CSystem, i->second, false);
     }
  
     // Read the system includes (C++ only)
     system_include = getIncludes("cxxsystem_includes.txt", jit_include);
     for (auto i=system_include.begin(); i!=system_include.end(); ++i) {
       compInst.getHeaderSearchOpts().AddPath(i->first,
                                              clang::frontend::CXXSystem, i->second, false);
     }
  
     // Search path
     std::stringstream paths;
     paths << include_path_ << pathsep();
     std::string path;
     while (std::getline(paths, path, pathsep())) {
       compInst.getHeaderSearchOpts().AddPath(path, clang::frontend::System, false, false);
     }
  
     // Create an LLVM context (NOTE: should use a static context instead?)
     context_ = new llvm::LLVMContext();
  
     // Create an action and make the compiler instance carry it out
     act_ = new clang::EmitLLVMOnlyAction(context_);
     if (!compInst.ExecuteAction(*act_))
       casadi_error("Cannot execute action");
  
     // Grab the module built by the EmitLLVMOnlyAction
     #if LLVM_VERSION_MAJOR>=4 || (LLVM_VERSION_MAJOR==3 && LLVM_VERSION_MINOR>=5)
     std::unique_ptr<llvm::Module> module = act_->takeModule();
     module_ = module.get();
     #else
     llvm::Module* module = act_->takeModule();
     module_ = module;
     #endif
  
     llvm::InitializeNativeTarget();
     llvm::InitializeNativeTargetAsmPrinter();
  
     // Create the JIT.  This takes ownership of the module.
     std::string ErrStr;
     executionEngine_ =
       llvm::EngineBuilder(std::move(module)).setEngineKind(llvm::EngineKind::JIT)
       .setErrorStr(&ErrStr).create();
     if (!executionEngine_) {
       casadi_error("Could not create ExecutionEngine: " + ErrStr);
     }
  
     executionEngine_->finalizeObject();
   }

References act_, casadi::casadi_register_importer_clang(), context_, executionEngine_, casadi::filesep(), flags_, getIncludes(), include_path_, casadi::ImporterInternal::init(), module_, myerr_, casadi::ImporterInternal::name_, casadi::path(), casadi::pathsep(), and casadi::uerr().

◆ initSingleton()

void casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::initSingleton ( )

inlineprotectedinherited

Called in the constructor of singletons to avoid that the counter reaches zero

Definition at line 71 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(static_cast<Internal*>(this)->count==0);
       static_cast<Internal*>(this)->count++;
     }

◆ inlined()

bool casadi::ImporterInternal::inlined ( const std::string & symname ) const

inherited

Definition at line 301 of file importer_internal.cpp.

                                                                {
     auto it = external_.find(symname);
     return it!=external_.end() && it->second.first;
   }

References casadi::ImporterInternal::external_.

Referenced by casadi::ImporterInternal::init(), and casadi::ImporterInternal::read_external().

◆ instantiate()

ImporterInternal * casadi::PluginInterface< ImporterInternal >::instantiate	(	const std::string &	fname,
		const std::string &	pname,
		Problem	problem
	)

staticinherited

Definition at line 106 of file plugin_interface.hpp.

                                                        {
  
     // Assert the plugin exists (needed for adaptors)
     if (!has_plugin(pname, true)) {
       casadi_error("Plugin '" + pname + "' is not found.");
     }
     return getPlugin(pname).creator(fname, problem);
   }

◆ library()

std::string casadi::ImporterInternal::library ( ) const

virtualinherited

Reimplemented in casadi::ShellCompiler, and casadi::DllLibrary.

Definition at line 312 of file importer_internal.cpp.

                                             {
     casadi_error("library not implemented.");
   }

◆ load_library()

handle_t casadi::PluginInterface< ImporterInternal >::load_library	(	const std::string &	libname,
		std::string &	resultpath,
		bool	global
	)

staticinherited

Definition at line 92 of file plugin_interface.hpp.

                                         {
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
  
     // Get the name of the shared library
     std::string lib = std::string(CasadiMeta::shared_library_prefix()) + libname +
                       CasadiMeta::shared_library_suffix();
  
     // Build up search paths;
     std::vector<std::string> search_paths = get_search_paths();
     return open_shared_library(lib, search_paths, resultpath,
       "PluginInterface::load_plugin", global);
  
 #endif // WITH_DL
   }

◆ load_plugin()

PluginInterface< ImporterInternal >::Plugin casadi::PluginInterface< ImporterInternal >::load_plugin	(	const std::string &	pname,
		bool	register_plugin = `true`,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 88 of file plugin_interface.hpp.

                                                {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Issue warning and quick return if already loaded
     if (Derived::solvers_.find(pname) != Derived::solvers_.end()) {
       casadi_warning("PluginInterface: Solver " + pname + " is already in use. Ignored.");
       return Plugin();
     }
  
     // Logger singletons are lazily instantiated on first uout()/uerr() calls
     // This instantation may lead to a data race with potential instatiations in plugin
     // To be safe, trigger instantatin before any plugin loading
     uout();
     uerr();
  
 #ifndef WITH_DL
     casadi_error("WITH_DL option needed for dynamic loading");
 #else // WITH_DL
     // Retrieve the registration function
     RegFcn reg;
  
     // Load the dll
     std::string regName = "casadi_register_" + Derived::infix_ + "_" + pname;
  
     std::string searchpath;
     handle_t handle = load_library("casadi_" + Derived::infix_ + "_" + pname, searchpath,
       false);
  
 #ifdef _WIN32
  
 #if __GNUC__
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
 #endif
     reg = reinterpret_cast<RegFcn>(GetProcAddress(handle, TEXT(regName.c_str())));
 #if __GNUC__
 #pragma GCC diagnostic pop
 #endif
  
 #else // _WIN32
     // Reset error
     dlerror();
  
     // Load creator
     reg = reinterpret_cast<RegFcn>(dlsym(handle, regName.c_str()));
 #endif // _WIN32
     casadi_assert(reg!=nullptr,
       "PluginInterface::load_plugin: no \"" + regName + "\" found in " + searchpath + ".");
  
     // Create a temporary struct
     Plugin plugin = pluginFromRegFcn(reg);
     // Register the plugin
     if (register_plugin) {
       registerPlugin(plugin, false);
     }
  
     return plugin;
  
 #endif // WITH_DL
   }

◆ plugin_deserialize()

Deserialize casadi::PluginInterface< ImporterInternal >::plugin_deserialize ( const std::string & pname )

staticinherited

Definition at line 82 of file plugin_interface.hpp.

                                                                                  {
     Deserialize m = getPlugin(pname).deserialize;
     casadi_assert(m, "Plugin \"" + pname + "\" does not support deserialize");
     return m;
   }

◆ plugin_name()

const char* casadi::ClangCompiler::plugin_name ( ) const

inlineoverridevirtual

Reimplemented from casadi::ImporterInternal.

Definition at line 110 of file clang_compiler.hpp.

110 { return "clang";}

◆ plugin_options()

const Options & casadi::PluginInterface< ImporterInternal >::plugin_options ( const std::string & pname )

staticinherited

Definition at line 79 of file plugin_interface.hpp.

                                                                                 {
     const Options *op = getPlugin(pname).options;
     casadi_assert(op!=nullptr, "Plugin \"" + pname + "\" does not support options");
     return *op;
   }

◆ pluginFromRegFcn()

PluginInterface< ImporterInternal >::Plugin casadi::PluginInterface< ImporterInternal >::pluginFromRegFcn ( RegFcn regfcn )

staticinherited

Definition at line 85 of file plugin_interface.hpp.

                                                               {
     // Create a temporary struct
     Plugin plugin;
  
     // Set the fields
     int flag = regfcn(&plugin);
     casadi_assert(flag==0, "Registration of plugin failed.");
  
     return plugin;
   }

◆ read_external()

void casadi::ImporterInternal::read_external	(	const std::string &	sym,
		bool	inlined,
		std::istream &	file,
		casadi_int &	offset
	)

inherited

Definition at line 182 of file importer_internal.cpp.

                                                                                           {
     // New entry
     std::stringstream ss;
  
     // Are we still in the function declaration
     bool in_declaration = true;
  
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // Skip line if still in declaration
       if (in_declaration) {
         size_t stop = line.find('{');
         if (stop != std::string::npos) in_declaration = false;
         continue;
       }
  
       // End of declaration found?
       if (line.find("/*CASADIEXTERNAL") != std::string::npos) {
         auto new_el = external_.insert(std::make_pair(sym, std::make_pair(inlined, ss.str())));
         casadi_assert(new_el.second, "Duplicate symbol: \"" + sym + "\"");
         return;
       }
  
       // Add to entry
       if (inlined) {
         ss << line << std::endl;
       }
     }
     casadi_error("End-of-file reached while searching for \"/*CASADIEXTERNAL\"");
   }

References casadi::ImporterInternal::external_, and casadi::ImporterInternal::inlined().

Referenced by casadi::ImporterInternal::init().

◆ read_meta()

void casadi::ImporterInternal::read_meta	(	std::istream &	file,
		casadi_int &	offset
	)

inherited

Definition at line 135 of file importer_internal.cpp.

                                                                        {
     // Loop over the lines
     std::string line;
     while (getline(file, line)) {
       offset++;
  
       // End of meta found?
       if (line.find("*/") != std::string::npos) return;
  
       // If comment or empty line, skip
       if (line.empty() || line.at(0)=='#') continue;
  
       // Get command string
       casadi_assert(line.at(0)==':',
                             "Syntax error: " + line + " is not a command string");
       std::string cmd = line.substr(1, line.find(' ')-1);
  
       // New entry
       std::stringstream ss;
  
       // Collect the meta data
       line = line.substr(cmd.size()+2);
       while (true) {
         // Find the backslash, if any
         size_t stop = line.find('\\');
  
         // Add to entry
         ss << line.substr(0, stop);
  
         // Break if not multiline
         if (stop == std::string::npos) break;
  
         // Read another line
         ss << std::endl;
         if (!getline(file, line)) {
           casadi_error("Failed to read \"" + cmd + "\"");
         }
         offset++;
       }
  
       // Insert new element in map
       auto new_el = meta_.insert(std::make_pair(cmd, std::make_pair(offset, ss.str())));
       casadi_assert(new_el.second, "Duplicate entry: \"" + cmd + "\"");
     }
     casadi_error("End-of-file reached while searching for \"*/\"");
   }

References casadi::ImporterInternal::meta_.

Referenced by casadi::ImporterInternal::init().

◆ registerPlugin() [1/2]

void casadi::PluginInterface< ImporterInternal >::registerPlugin	(	const Plugin &	plugin,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 96 of file plugin_interface.hpp.

                                                                                      {
  
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     casadi::conditional_lock_guard<std::mutex> lock(Derived::mutex_solvers_, needs_lock);
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
  
     // Check if the solver name is in use
     typename std::map<std::string, Plugin>::iterator it=Derived::solvers_.find(plugin.name);
     casadi_assert(it==Derived::solvers_.end(),
       "Solver " + str(plugin.name) + " is already in use");
  
     // Add to list of solvers
     Derived::solvers_[plugin.name] = plugin;
   }

◆ registerPlugin() [2/2]

void casadi::PluginInterface< ImporterInternal >::registerPlugin	(	RegFcn	regfcn,
		bool	needs_lock = `true`
	)

staticinherited

Definition at line 99 of file plugin_interface.hpp.

                                                                               {
     registerPlugin(pluginFromRegFcn(regfcn), needs_lock);
   }

◆ serialize()

void casadi::ImporterInternal::serialize ( SerializingStream & s ) const

inherited

Definition at line 316 of file importer_internal.cpp.

                                                              {
     serialize_type(s);
     serialize_body(s);
   }

References casadi::ImporterInternal::serialize_body(), and casadi::ImporterInternal::serialize_type().

◆ serialize_body()

void casadi::ImporterInternal::serialize_body ( SerializingStream & s ) const

virtualinherited

Definition at line 325 of file importer_internal.cpp.

                                                                   {
     s.version("ImporterInternal", 1);
     s.pack("ImporterInternal::name", name_);
     s.pack("ImporterInternal::meta", meta_);
     s.pack("ImporterInternal::external", external_);
   }

References casadi::ImporterInternal::external_, casadi::ImporterInternal::meta_, casadi::ImporterInternal::name_, casadi::SerializingStream::pack(), and casadi::SerializingStream::version().

Referenced by casadi::ImporterInternal::serialize().

◆ serialize_type()

void casadi::ImporterInternal::serialize_type ( SerializingStream & s ) const

virtualinherited

Definition at line 321 of file importer_internal.cpp.

                                                                   {
     s.pack("ImporterInternal::type", class_name());
   }

References casadi::ImporterInternal::class_name(), and casadi::SerializingStream::pack().

Referenced by casadi::ImporterInternal::serialize().

◆ shared_from_this() [1/2]

B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( )

inlineprotectedinherited

Definition at line 83 of file generic_shared_internal.hpp.

                          {
       casadi_assert_dev(B::test_cast(static_cast<Internal*>(this)));
       B ret;
       ret.own(static_cast<Internal*>(this));
       return ret;
     }

◆ shared_from_this() [2/2]

const B casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::shared_from_this ( ) const

inlineprotectedinherited

Definition at line 92 of file generic_shared_internal.hpp.

                                      {
       casadi_assert_dev(B::test_cast(static_cast<const Internal*>(this)));
       B ret;
       ret.own(const_cast<Internal*>(static_cast<const Internal*>(this)));
       return ret;
     }

◆ shortname()

static std::string casadi::ImporterInternal::shortname ( )

inlinestaticinherited

Definition at line 104 of file importer_internal.hpp.

104 { return "importer";}

◆ to_text()

std::string casadi::ImporterInternal::to_text	(	const std::string &	cmd,
		casadi_int	ind = `-1`
	)		const

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21g

◆ weak()

GenericWeakRef< SharedObject , SharedObjectInternal > * casadi::GenericSharedInternal< SharedObject , SharedObjectInternal >::weak

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_1ai

Definition at line 67 of file generic_shared_internal.hpp.

                                                                                   {
 #ifdef CASADI_WITH_THREADSAFE_SYMBOLICS
     auto* w = weak_ref_.load(std::memory_order_acquire);
     if (!w) {
       auto* nw = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
       GenericWeakRef<Shared, Internal>* expected = nullptr;
       if (weak_ref_.compare_exchange_strong(
             expected, nw, std::memory_order_release, std::memory_order_acquire)) {
         w = nw;
       } else {
         delete nw; // lost the race; another thread published first
         w = expected;
       }
     }
     return w;
 #else
     if (weak_ref_==nullptr) {
       weak_ref_ = new GenericWeakRef<Shared, Internal>(static_cast<Internal*>(this));
     }
     return weak_ref_;
 #endif // CASADI_WITH_THREADSAFE_SYMBOLICS
   }

Member Data Documentation

◆ act_

clang::EmitLLVMOnlyAction* casadi::ClangCompiler::act_

protected

Definition at line 127 of file clang_compiler.hpp.

Referenced by ClangCompiler(), init(), and ~ClangCompiler().

◆ context_

llvm::LLVMContext* casadi::ClangCompiler::context_

protected

Definition at line 129 of file clang_compiler.hpp.

Referenced by ClangCompiler(), init(), and ~ClangCompiler().

◆ executionEngine_

llvm::ExecutionEngine* casadi::ClangCompiler::executionEngine_

protected

Definition at line 128 of file clang_compiler.hpp.

Referenced by ClangCompiler(), get_function(), init(), and ~ClangCompiler().

◆ external_

std::map<std::string, std::pair<bool, std::string> > casadi::ImporterInternal::external_

inherited

Definition at line 163 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::body(), casadi::ImporterInternal::has_function(), casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::inlined(), casadi::ImporterInternal::read_external(), and casadi::ImporterInternal::serialize_body().

◆ flags_

std::vector<std::string> casadi::ClangCompiler::flags_

Definition at line 124 of file clang_compiler.hpp.

Referenced by init().

◆ include_path_

std::string casadi::ClangCompiler::include_path_

Definition at line 123 of file clang_compiler.hpp.

Referenced by init().

◆ infix_

const std::string casadi::ImporterInternal::infix_ = "importer"

staticinherited

Definition at line 101 of file importer_internal.hpp.

◆ meta_

std::map<std::string, std::pair<casadi_int, std::string> > casadi::ImporterInternal::meta_

inherited

Definition at line 160 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::get_meta(), casadi::ImporterInternal::has_meta(), casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::read_meta(), and casadi::ImporterInternal::serialize_body().

◆ meta_doc

const std::string casadi::ClangCompiler::meta_doc

static

Initial value:

=
      "\n"
"\n"
"\n"
"Interface to the JIT compiler CLANG\n"
"\n"
"Extra doc: https://github.com/casadi/casadi/wiki/L_21v \n"
"\n"
"\n"
">List of available options\n"
"\n"
"+--------------+-----------------+-----------------------------------------+\n"
"|      Id      |      Type       |               Description               |\n"
"+==============+=================+=========================================+\n"
"| flags        | OT_STRINGVECTOR | Compile flags for the JIT compiler.     |\n"
"|              |                 | Default: None                           |\n"
"+--------------+-----------------+-----------------------------------------+\n"
"| include_path | OT_STRING       | Include paths for the JIT compiler. The |\n"
"|              |                 | include directory shipped with CasADi   |\n"
"|              |                 | will be automatically appended.         |\n"
"+--------------+-----------------+-----------------------------------------+\n"
"\n"
"\n"
"\n"
"\n"

Definition at line 107 of file clang_compiler.hpp.

Referenced by casadi::casadi_register_importer_clang().

◆ module_

llvm::Module* casadi::ClangCompiler::module_

protected

Definition at line 131 of file clang_compiler.hpp.

Referenced by get_function(), and init().

◆ myerr_

llvm::raw_ostream* casadi::ClangCompiler::myerr_

protected

Definition at line 130 of file clang_compiler.hpp.

Referenced by ClangCompiler(), init(), and ~ClangCompiler().

◆ name_

std::string casadi::ImporterInternal::name_

inherited

Definition at line 157 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::init(), init(), casadi::ShellCompiler::init(), casadi::DllLibrary::init_handle(), casadi::DllLibrary::library(), and casadi::ImporterInternal::serialize_body().

◆ options_

const Options casadi::ClangCompiler::options_

static

Initial value:

= {{&ImporterInternal::options_},
     {{"include_path",
       {OT_STRING,
        "Include paths for the JIT compiler. "
        "The include directory shipped with CasADi will be automatically appended."}},
      {"flags",
       {OT_STRINGVECTOR,
        "Compile flags for the JIT compiler. Default: None"}}
     }
  }

Definition at line 99 of file clang_compiler.hpp.

Referenced by casadi::casadi_register_importer_clang().

◆ solvers_

std::map< std::string, ImporterInternal::Plugin > casadi::ImporterInternal::solvers_

staticinherited

Definition at line 94 of file importer_internal.hpp.

◆ verbose_

bool casadi::ImporterInternal::verbose_

inherited

Extra doc: https://github.com/casadi/casadi/wiki/L_21h

Definition at line 168 of file importer_internal.hpp.

Referenced by casadi::ImporterInternal::ImporterInternal(), casadi::ImporterInternal::init(), and casadi::ShellCompiler::init().

The documentation for this class was generated from the following files:

Detailed Description

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Protected Attributes

Member Typedef Documentation

◆ Creator

◆ RegFcn

◆ weak_ref_type

Constructor & Destructor Documentation

◆ ClangCompiler()

◆ ~ClangCompiler()

Member Function Documentation

◆ body()

◆ can_have_meta()

◆ class_name()

◆ construct()

◆ creator()

◆ debug_repr()

◆ deps_version_check()

◆ deserialize()

◆ destroySingleton()

◆ disp()

◆ finalize()

◆ get_function()

◆ get_meta()

◆ get_options()

◆ getCount()

◆ getIncludes()

◆ getPlugin()

◆ has_function()

◆ has_meta()

◆ has_plugin()

◆ indexed()

◆ init()

◆ initSingleton()

◆ inlined()

◆ instantiate()

◆ library()

◆ load_library()

◆ load_plugin()

◆ plugin_deserialize()

◆ plugin_name()

◆ plugin_options()

◆ pluginFromRegFcn()

◆ read_external()

◆ read_meta()

◆ registerPlugin() [1/2]

◆ registerPlugin() [2/2]

◆ serialize()

◆ serialize_body()

◆ serialize_type()

◆ shared_from_this() [1/2]

◆ shared_from_this() [2/2]

◆ shortname()

◆ to_text()

◆ weak()

Member Data Documentation

◆ act_

◆ context_

◆ executionEngine_

◆ external_

◆ flags_

◆ include_path_

◆ infix_

◆ meta_

◆ meta_doc

◆ module_

◆ myerr_

◆ name_

◆ options_

◆ solvers_

◆ verbose_