CorePy: Assembly Programming in Python

http://www.corepy.org/

by mace • 18 years ago

68 27 18 years ago

corepy.org

est• 18 years ago

> "CorePy makes assembly fun again!" (Alex Breuer)

riobard• 18 years ago

any body benchmarked the performance of CorePy?

snorkel• 18 years ago

No, but I'd assume any intense math operations that happen inside a loop would be much faster.

wheels3• 18 years ago

Then your understanding of machine language and compilers would be flawed.

In most cases the compiler will do a better job at optimizing machine code than humans will.

juliend2• 18 years ago

Wow. So cool.

Thanks for this news.

illume• 18 years ago

This is great because it allows you to create algorithms at runtime for your data.

So rather than doing...

def doit(option1, data): for x in data: if option1: x += 7

You can create a function that doesn't include the "if option1" part. This is great if you have many different options... and instead of bloating your code for many different optimized function, or one slower generic function, you can create the optimized functions at run time.

Looks very nice. I just wish it had support for 3dnow, and windows :)

flashgordon2• 18 years ago

i would have liked to see llvm bindings to python... i am sure they are out there...

flashgordon2• 18 years ago

sure enough!!!

http://code.google.com/p/llvm-py/

tptacek3• 18 years ago

We've got something similar in Ruby (we're not the first, and ours is nowhere nearly as mature as CorePy). We use it for building ad-hoc debuggers for reversing targets that don't support native debugging and tracing interfaces.

Ruby is an excellent language for this, because it gets out of the way. Here's a Rasm snippet:

            @epilog ||= @prog.add {
                push ebx 
                mov ebx, retv
                mov [ebx], eax
                pop ebx
                xor eax, eax
                ret
            }

Obviously, that's all pure Ruby.

Once you have a class mapping for each of the instructions in your target ISA --- way easier than it sounds --- getting your code to jump into a runtime generated buffer is pretty easy.

We're starting to throw code onto Github; I've been thinking about publishing this, but didn't think it would be very interesting, except as a hack.

tc• 18 years ago

SBCL has an extremely sophisticated facility called a VOP (Virtual Operation) that allows you to write assembly with s-expressions and integrate the code into the compiler and runtime. The SBCL backend itself is composed of these VOPs.

Significantly, this means that you can write assembly macros with the full power and elegance of lisp. A trivial example is the move macro, which is used extensively in VOPs:

  (defmacro move (dst src)
    "Move SRC into DST unless they are location=."
    (once-only ((n-dst dst)
                (n-src src))
      `(unless (location= ,n-dst ,n-src)
         (inst mov ,n-dst ,n-src))))

Check out the SBCL source if you want to see some wild uses of VOPs and macros that expand into assembly code. In compiler/x86/arith.lisp there is a lisp/assembly implementation of the Mersenne Twister.

VOPs can optionally handle argument type checking and can be tuned to emit specialized code in various circumstances, such as when one of the arguments to the call is a compile-time constant.

tptacek3• 18 years ago

What I want to see is Python or Ruby taking advantage of a runtime code generation library to start rewriting the VM or JIT'ing method calls.

kragen• 18 years ago

That's really nice. I'd love to see the code, even if there are other "something similar"s in Ruby. Did you actually implement the entire x86 instruction set, or just the parts of it you have used so far?

CorePy: Assembly Programming in Python

Related Stories