similar to: Execution

​Hi all, I am using llvmlite for pyvex and I want the output of my code (which is written based on llvmlite) to be like pyvex. In pyvex, (https://github.com/angr/pyvex). Considering pyvex, I tried to implement the following statements in pyvex to llvmlite: for stmt in irsb.statements: if isinstance(stmt, pyvex.IRStmt.Store): print "ST%s(%s) = %s" % (self.endness[-2:].lower(),

Hi, I wrote yet another [1,2] Python binding for LLVM! I'm doing this because llvmlite has some serious limitations: 1) it cannot parse an existing IR, only create new modules [3], 2) it keeps its own representation of the IR (which is less memory efficient than the LLVM one), and 3) each llvmlite version supports a single LLVM version. Considering that my need is to load modules of hundreds

2016-01-20 1:11 GMT+02:00 Antoine Pitrou via llvm-dev < llvm-dev at lists.llvm.org>: > On Wed, 20 Jan 2016 00:47:56 +0200 > "Eddy B. via llvm-dev" <llvm-dev at lists.llvm.org> wrote: > > > > I would love to know your thoughts on this, and more specifically: > > Which of the 3 (byval(T), byval(N) and byval + dereferenceable + align) > > do you

On Thu, 12 May 2016 16:40:44 +0100 David Chisnall via cfe-dev <cfe-dev at lists.llvm.org> wrote: > > The end result is that shortly after a release (sometimes every alternate release) is branched a load of downstream projects update to the new APIs, test things, and find a bunch of regressions that have been sitting in the tree for months. We then have to scrabble to bisect and try

Hi there, Sorry, I don't have the thread history to reply to since I normally read llvmdev through the archives, but wanted to give my .02 of feedback anyway. As far as I understand, this change is wanted because the LLVM infrastructure derives no value from knowing the types, and there's a cost in terms of code spent to support all of it. I've been creating a frontend that mostly

On Tue, Feb 17, 2015 at 8:56 AM, Antoine Pitrou <antoine at python.org> wrote: > > Hi, > > Dirkjan Ochtman <dirkjan <at> ochtman.nl> writes: > > > > As far as I understand, this change is wanted because the LLVM > > infrastructure derives no value from knowing the types, and there's a > > cost in terms of code spent to support all of it.

Hal Finkel <hfinkel <at> anl.gov> writes: > > Do you require long-term cross-release ABI and/or API stability > from the C API that you're using? Do these > other projects? For the record, in llvmlite and Numba we don't require C API stability for two reasons: 1) the C API is not enough for us and we rely on bits of the C++ API 2) we also rely on other details

LLVM Weekly - #57, Feb 2nd 2015 =============================== If you prefer, you can read a HTML version of this email at <http://llvmweekly.org/issue/57>. Welcome to the fifty-seventh issue of LLVM Weekly, a weekly newsletter (published every Monday) covering developments in LLVM, Clang, and related projects. LLVM Weekly is brought to you by [Alex Bradbury](http://asbradbury.org).

On 12 May 2016 at 16:56, Kristof Beyls <Kristof.Beyls at arm.com> wrote: > In my opinion, it would be better overall for the LLVM project if > top-of-trunk is > tested as much as possible, if testing resources are so scarce that a > choice > has to be made between testing top-of-trunk or testing a release branch. > I agree that trunk is more important, with both of my

Hi, In the past months, several options have been presented for making byval (and similar attributes, such as inalloca or sret) work with opaque pointers. The main two I've seen were byval(T) and byval(N) where N is the size of T. They both have their upsides and downsides, for example: byval(T) would be a type-parametric attribute, which, AFAIK, does not already exist and may complicate

Hi all, First, I just want to say thank you for the excellent LLVM project. I have been playing with LLVM for the first part of this year and have been quite impressed with what I've seen and what is possible. I've been coding for a long time, but haven't had this much fun since I first learned Python. The work you have done has opened the door for a tremendous amount of

If you didn't catch it, there has been a recent post to the mailing list that seems like it might be relevant to your interests: <http://lists.cs.uiuc.edu/pipermail/llvmdev/2012-June/051298.html> Direct link to the project page: <http://code.google.com/p/pymothoa/> --Sean Silva On Wed, Jul 11, 2012 at 12:37 AM, Travis Oliphant <travis at continuum.io> wrote: > Hi all,

Hello, We are happy to release version 0.10.0 of llvmlite. llvmlite is a light-weight Python binding for LLVM (compatible with Python 2.7 as well as Python 3.4 and later). It stems from the needs of the Numba community and is geared towards creating JIT compilers. llvmlite is available both as source code and as binaries for a number of platforms. Source code is available on PyPI and Github:

Thanks, happy to of confirmed. With that in mind, will use the AST modules provided by the languages (with the exception of libclang for C++). Antoine: Am aware of Numba, nice job there BTW. So is there a [decoupled] LLVM parser which I can use to read Python files and analyse objects (including computing their attributes in OO and setattr scenarios)? On Wed, Jul 1, 2015 at 10:23 PM, Antoine

IIRC when LLVM came out a bunch of community-contributed parsers were available on your website. Essentially I want to read in a programming language, prune the AST until it contains only what I define as a "summary", then convert that AST to that of another language, before finally outputting [code-generating] a compilable/interpretable source [think boilerplate]. Would be good to

There is llvmlite http://llvmlite.readthedocs.io/en/latest/ , but it doesn't seem to support reading individual instructions, based on these docs. I was thinking to make a simple code analysis tool to, for example, find all system calls that have unchecked return codes, but I can't find a binding for any scripting language. And I am averse to writing this in C++. Thanks, Yuri

Yep we have our own parser <https://github.com/vinzenz/libpypa/> and we would love to see other people use it. When we looked around at some other Python parsers we didn't feel like any of them were easy to extract and use on their own, so we wrote our own and I think were able to keep ours well-separated. There are some things that make parsing Python somewhat difficult to do in a

When I compile my C fibonacci example fib.c with 'clang -O3 -c -emit-llvm -o fib-clang.bc fib.c&& llvm-dis fib-clang.bc' I get fib-clang.ll that has some degree of inlining in it. But when I get an equivalent to fib.c file fib.ll and run it through opt with the command 'llvm-as fib.ll&& opt -O3 fib.bc -o fib-opt.bc&& llvm-dis fib-opt.bc' resulting

Hi Ulrich, and any other llvm PowerPC/JIT users, It looks like the Numba maintainers have run in to an issue with RuntimeDyldELF's PowerPC support (See https://github.com/numba/numba/issues/2451#issuecomment-377739948 and later comments) Due to a recent change to weak symbol handling, we now always resolve to the first copy of a function that is emitted (discarding redundant weak/odr

Hi LLVMers, the example attached I have used to prove that JIT and some visible optimizations are really invoked. Proved OK. I got 30% speed-up in comparison to gcc 3.3.3 on my Athlon XP 1500. Nice. P.S. guys, no fears, I don't plan to flood the cvs repository with my "brilliant" examples ;) --- Valery A.Khamenya -------------- next part -------------- An