I would like to use llc -march=ia64 to generate the assembly but that is
not supported at the moment.
As a workaround I let llc generate C code that gets compiled, but this
unfortunately is not a good way
to show the power of llvm. A understood this ia64 support will be worked
on soon.
First week of july there will be a pypy-sprint in Goteborg (Sweden)
where the focus will be on translating Python code to other languages
like LLVM,C,Lisp,Java,etc..
Is there a change llc will support ia64 in about 4 weeks time or am I to
optimistic?
The IA64 architecture, which had its 'official' name changed to the "Itanium Processor Architecture", *is* supported by llc. I am pretty sure you are talking about the x86-64 architecture, which has also had its share of unfortunate name changes and is also known as "AMD64", "EM64T" and all sorts of things in between. x86-64 is *not* currently supported by llc.
I am not aware of anyone working to add x86-64 support to llc, but such support will probably come one day. The author of LLVM's x86 backend is enjoying some well-earned time off right now, so I think 4 weeks is probably a bit too optimistic, sorry about that.
Having said that, is there no way you can use the assembly that results from passing "-march=x86" to llc? I think you should be able to create a 32-bit "playground" on your x86-64 system, and build and run LLVM and PyPy inside that. The idea here is to try and fool LLVM into thinking it's running on a plain old x86 system. I'm pretty sure this is possible, but it has been a long time since I last used an x86-64 system, so I can't tell you exactly what you need to do. Someone else on this list might be able to help you out, though. (Markus, are you reading this?
You are right, the machine I am on is a AMD Opteron. I could probably
generate working code for x86, but I am testing the implications of
using 64 bits integers. The four weeks is not really important, it's
just that it would be nice to have really fast code to showcase.
Something related to this: to test the effect of 64 bits integers I
replace all reference of int by long in my .ll file.
The work just fine except for some instruction (like malloc) that demand
an uint and not an ulong.
With the shift from the 32 to the 64 bit world, is this something that
will be enhanced in the future, or would that have to much impact on the
existing llvm codebase?
You are right, the machine I am on is a AMD Opteron. I could probably
generate working code for x86, but I am testing the implications of
using 64 bits integers. The four weeks is not really important, it's
just that it would be nice to have really fast code to showcase.
In general, the "C" backend that you're using now is the fastest choice
overall. Although LLVM's x86 backend smokes GCC on several tests, it is
also considerably worse on others. See the nightly test results for
details. So, it depends on what your program does, but you might want to
just stick with the "C" backend to provide reasonable performance until
the x86_64 backend is completed. There was someone working on this a
while back but I forget who. If you want to *really* tune things, you
could write the x86_64 backend to your own specifications ;>
Something related to this: to test the effect of 64 bits integers I
replace all reference of int by long in my .ll file.
The work just fine except for some instruction (like malloc) that demand
an uint and not an ulong.
With the shift from the 32 to the 64 bit world, is this something that
will be enhanced in the future, or would that have to much impact on the
existing llvm codebase?
I assume you mean the "count" operand of the malloc instruction should
be able to take any size unsigned operand. This probably wouldn't be a
huge hit to the codebase as its limited to a single instruction and it
is a relaxation of requirements rather than a tightening. I think,
however, we'll have to wait for Chris to come back from vacation to
determine whether this is a good idea or not. There are *major* changes
planned to the type system (e.g. move distinction of signedness to the
instructions and not have them in the types) in the 2.0 time frame and
this change could be wrapped into that one. However, the 2.0 time frame
is probably not soon enough (2006 probably) for your project.
LLVM already has support for several 64 bit architectures, including
alpha, itanium, and sparcv9 (also ppc64 to some extent). So no, no
major impact for those who waited to use 64 bit archs until this
century
Something related to this: to test the effect of 64 bits integers I replace all reference of int by long in my .ll file. The work just fine except for some instruction (like malloc) that demand an uint and not an ulong. With the shift from the 32 to the 64 bit world, is this something that will be enhanced in the future, or would that have to much impact on the existing llvm codebase?
LLVM already supports 64-bit systems pretty well, including IA-64, Alpha and SparcV9. There are minor vestigial issues that prevent allocation of some objects > 4GB in size (such as the above), but these will be fixed in time (sooner if we get help)
-Chris
Duraid Madina wrote:
Hi there,
The IA64 architecture, which had its 'official' name changed to
the "Itanium Processor Architecture", *is* supported by llc. I am
pretty sure you are talking about the x86-64 architecture, which has
also had its share of unfortunate name changes and is also known as
"AMD64", "EM64T" and all sorts of things in between. x86-64 is *not*
currently supported by llc.
I am not aware of anyone working to add x86-64 support to llc, but
such support will probably come one day. The author of LLVM's x86
backend is enjoying some well-earned time off right now, so I think 4
weeks is probably a bit too optimistic, sorry about that.
Having said that, is there no way you can use the assembly that
results from passing "-march=x86" to llc? I think you should be able
to create a 32-bit "playground" on your x86-64 system, and build and
run LLVM and PyPy inside that. The idea here is to try and fool LLVM
into thinking it's running on a plain old x86 system. I'm pretty sure
this is possible, but it has been a long time since I last used an
x86-64 system, so I can't tell you exactly what you need to do.
Someone else on this list might be able to help you out, though.
(Markus, are you reading this?
I would like to use llc -march=ia64 to generate the assembly but that is
not supported at the moment.
As a workaround I let llc generate C code that gets compiled, but this
unfortunately is not a good way
to show the power of llvm. A understood this ia64 support will be worked
on soon.
First week of july there will be a pypy-sprint in Goteborg (Sweden)
where the focus will be on translating Python code to other languages
like LLVM,C,Lisp,Java,etc..
Is there a change llc will support ia64 in about 4 weeks time or am I to
optimistic?
