{"id":1546,"date":"2017-03-27T06:32:46","date_gmt":"2017-03-27T10:32:46","guid":{"rendered":"http:\/\/codinggorilla.domemtech.com\/?p=1546"},"modified":"2017-08-29T12:33:19","modified_gmt":"2017-08-29T16:33:19","slug":"swig-llvm-llilc","status":"publish","type":"post","link":"http:\/\/165.227.223.229\/index.php\/2017\/03\/27\/swig-llvm-llilc\/","title":{"rendered":"Swig, LLVM, LLILC"},"content":{"rendered":"

As I work to enhance Campy, a C# library for GPU programming I wrote, I’m trying to capitalize on some new code from the NET Foundation Projects<\/a>. These include LLILC<\/a>, a MS IL compiler based on LLVM. I want to be able to use some of the APIs in LLVM to perform SSA analysis rather than roll my own. But, that turns out to be easier said than done. This note describes some of the issues in building LLILC, LLVM, and SWIG.<\/p>\n

<\/p>\n

\n

SWIG<\/h3>\n

Simplified Wrapper and Interface Generator (SWIG) is a tool to generate a wrapper in one programming language from the API written in another language. SWIG has the capability to parse C\/C++ header files and output C# classes and native C interfaces that perform PInvoke calls for C#. It is a reasonable choice when one wants to create a C# interface to LLVM, or any C++ API for that matter.<\/p>\n

However, SWIG is baroque, if not outright grotesque. The rules for type mapping C++ to C# are difficult to understand, even with full debugging enabled (-debug-memory -debug-classes -debug-symtabs -debug-tmsearch -debug-tmused -debug-symbols -debug-csymbols -debug-lsymbols -debug-typemap -debug-template). Conversion of basics<\/a> like void* -> IntPtr<\/em> are not handled out of the box.<\/p>\n

While SWIG can run on Windows, I find that it is easier to build in a Linux shell, and call the command-line tool via WSL<\/a>, e.g., bash -c swig ….\u00c2\u00a0<\/em>That said, Swig is one of those tools in which you sometimes need to debug the code in order to understand the type mapping rules–not that that will be easy as almost every object in SWIG is encoded as what the authors call a DOH object<\/a><\/em>— which is just a void*<\/em>.<\/p>\n

Installation:<\/h4>\n\n

Example:<\/h4>\n


\n(Note! If you make your own API, make sure to update the .SLN file with a <ProjectReference> entry. See https:\/\/blogs.msdn.microsoft.com\/kirillosenkov\/2015\/04\/04\/how-to-have-a-project-reference-without-referencing-the-actual-binary\/<\/a>)<\/p>\n

Resources:<\/h4>\n

http:\/\/swig.org<\/a>
\nhttps:\/\/sourceforge.net\/projects\/swig\/<\/a><\/p>\n

Documentation:<\/h4>\n

http:\/\/swig.org\/Doc3.0\/SWIGDocumentation.html<\/a><\/p>\n

\n

Swigged LLVM<\/h3>\n

LLVM (Low Level Virtual Machine) is a compiler infrastructure project, and is the defacto tool for compiler writers nowadays (which is too bad, because it lacks some flexibility, and it is better for people to learn and know compiler theory).<\/p>\n

Building LLVM on Windows is well documented. However, if you want to call LLVM from C#, you will need to use SWIG to generate a thunking layer, or write your own. In fact, others have done so: LLVMSharp<\/a> and SharpLang<\/a>. However, SharpLang<\/a> is no longer active (as of November 2015<\/a>), and LLVMSharp<\/a>\u00c2\u00a0is not quite up to date (which may not matter if one is using the LLVM-C API), and does not expose the SSA analysis API.<\/p>\n

Using SWIG to generate a C# API does require some finesse. A basic SWIG input file might be:
\n
\nHowever, this will result in many poorly named C# files, e.g.,\u00c2\u00a0SWIGTYPE_p_LLVMTypeRef.cs<\/em>. Therefore, one should apply SWIG %typemap’s<\/em> to rename the types appropriately. SharpLang<\/a> uses this approach, and I’ve updated the rewrite rules slightly to handle more of the LLVM API. LLVMSharp<\/a> uses a different approach, using a home-grown tool\u00c2\u00a0to parse C\/C++ header files and convert them into wrappers.<\/p>\n

NB: SWIG\/LLVM is so difficult to understand, that I\u00c2\u00a0will be exploring it in a later post in this blog.<\/em><\/p>\n

Installation:<\/h4>\n\n

Example:<\/h4>\n

https:\/\/github.com\/kaby76\/swigged-llvm<\/a><\/p>\n

Resources:<\/h4>\n

http:\/\/llvm.org\/<\/a>
\nhttps:\/\/github.com\/llvm-mirror<\/a>
\nhttp:\/\/www.telegrid.enea.it\/SGI\/Altix\/Typemaps.pdf<\/a>
\nhttp:\/\/swig.org\/Doc3.0\/SWIGDocumentation.html<\/a><\/p>\n

Documentation:<\/h4>\n

http:\/\/llvm.org\/docs\/<\/a><\/p>\n

\n

LLILC<\/h3>\n

LLILC is a compiler backend for MS IL based on LLVM. It was started by Microsoft to address ahead-of-time (AOT) compilation of MS IL, different from the JIT compiler, RyuJIT<\/a>, the compiler backend since Net 4.6. The JIT compiler is not LLVM based.<\/p>\n

The main use I would have for LLILC is to convert MS IL into LLVM for code analysis. However, I am not interested in code generation; I want to use the SSA graph to answer some basic questions of what code is referenced when calling a Campy parallel-for.<\/p>\n

Unfortunately, LLILC is code that is difficult to understand. LLILC merges the parsing of MSIL, construction of a control-flow graph, and translation of MSIL into LLVM IR with each instruction that is parsed. Further,\u00c2\u00a0LLILC is CoreCLR dependent, which means this cannot be used with a NET Framework application (the reverse is possible).<\/p>\n

Installation:<\/h4>\n

See\u00c2\u00a0https:\/\/github.com\/dotnet\/llilc\/blob\/master\/Documentation\/Getting-Started-For-Windows.md<\/a><\/p>\n

Resources:<\/h4>\n

https:\/\/dotnetfoundation.org\/llilc<\/a>
\nhttps:\/\/github.com\/dotnet\/llilc<\/a>
\nhttps:\/\/github.com\/dotnet\/coreclr\/blob\/master\/Documentation\/botr\/ryujit-overview.md<\/a>
\nhttp:\/\/www.c-sharpcorner.com\/UploadFile\/b26131\/ryujit-the-64-bit-compiler-for-net\/<\/a>
\nhttps:\/\/github.com\/dotnet\/coreclr\/tree\/master\/src\/jit<\/a>
\nhttp:\/\/blog.llvm.org\/2015\/04\/llilc-llvm-based-compiler-for-dotnet.html<\/a><\/p>\n

 <\/p>\n","protected":false},"excerpt":{"rendered":"

As I work to enhance Campy, a C# library for GPU programming I wrote, I’m trying to capitalize on some new code from the NET Foundation Projects. These include LLILC, a MS IL compiler based on LLVM. I want to be able to use some of the APIs in LLVM to perform SSA analysis rather … <\/p>\n

Continue reading “Swig, LLVM, LLILC”<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[],"tags":[],"_links":{"self":[{"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/posts\/1546"}],"collection":[{"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/comments?post=1546"}],"version-history":[{"count":0,"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/posts\/1546\/revisions"}],"wp:attachment":[{"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/media?parent=1546"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/categories?post=1546"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/165.227.223.229\/index.php\/wp-json\/wp\/v2\/tags?post=1546"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}