llvm dev - Feb 2010 - [LLVMdev] llvm interpreter cannot execute llvm-gcc generated bitcode

Hello again!

We have fetched the latest llvm sources from repository and the
original problem has went away. Though now we are facing a new problem
with interpreter on the following c code:

--------------
#include <stdarg.h>
#include <stdio.h>

void doTheThing(int dummy, ...)
{
  va_list ap;
  int z;

  va_start(ap, dummy);
  while( (z = va_arg(ap, int))!=0)
  {
    printf("== %i ==\n", z);
  }
  va_end(ap);
}

int main()
{
  doTheThing(-1, 1, 2, 3, 0);
}
--------------

Running the bitcode of this example through interpreter yields
abnormal result (or even crash if we are very unlucky), whereas on jit
it is working fine.
We are using interpreter because our code is crashing on jit too and
when using the interpreter it is much easier to iron out the problems.
Although as it seems at the current state the interpreter is quite
unreliable.

Thank you,
Kristaps.


On Thu, Jan 28, 2010 at 8:04 PM, Nick Lewycky <nicholas at mxc.ca>
wrote:
> Kristaps Straupe wrote:
>>
>> Hi!
>>
>> We are compiling a very large C project in llvm and trying to execute
>> it in interpreter. There is a problem with executing the generated
>> bitcode.
>
> The interpreter is under-maintained in general, but this bug in particular
> is fixed SVN as-of r86428. Are you on a platform that isn't supported
by
> llvm's jit?
>
> Nick
>
>> We are using lli.exe and llvm-gcc.exe from official 2.6 LLVM release.
>>
>> We have localized the problem to following c code:
>> --------------------
>> int f(unsigned char x) __attribute__((noinline));
>>
>> int f(unsigned char x)
>> {
>>   return x - 1;
>> }
>>
>> int main()
>> {
>>    return f(1);
>> }
>> --------------------
>>
>>
>> Which generates following llvm assembly:
>> ----------
>> ; ModuleID = 'a.o'
>> target datalayout >>
>>
"e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:32:32"
>> target triple = "i386-mingw32"
>>
>> define i32 @f(i8 zeroext %x) nounwind readnone noinline {
>> entry:
>>   %0 = zext i8 %x to i32                          ;<i32>
 [#uses=1]
>>   %1 = add i32 %0, -1                             ;<i32>
 [#uses=1]
>>   ret i32 %1
>> }
>>
>> define i32 @main() nounwind readnone {
>> entry:
>>   %0 = tail call i32 @f(i8 zeroext 1) nounwind    ;<i32>
 [#uses=1]
>>   ret i32 %0
>> }
>> -----------
>>
>>
>> Finally calling it with:
>> ----------
>> llvm-gcc -c -emit-llvm -O2 a.c
>> lli -force-interpreter a.o
>> ----------
>>
>> Yields us:
>> -----------
>> "Assertion failed: width>  BitWidth&&  "Invalid
APInt ZeroExtend
>> request", file c:/proj/llvm/src/lib/Support/APInt.cpp, line
1064"
>> -----------
>> where both width and BitWidth have value "32".
>>
>>
>> Removing this assert in llvm source makes more similar (APInt related)
>> asserts fail later.
>>
>> Is that a problem with llvm-gcc or is there a fix in llvm source
>> available?
>>
>>
>> Thank you and we hope to hear from you soon.
>> _______________________________________________
>> LLVM Developers mailing list
>> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
>> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>>
>
>

On 02/01/2010 01:13 PM, Kristaps Straupe wrote:
> Hello again!
>
> We have fetched the latest llvm sources from repository and the
> original problem has went away. Though now we are facing a new problem
> with interpreter on the following c code:
>
> --------------
> #include <stdarg.h>
> #include <stdio.h>
>
> void doTheThing(int dummy, ...)
> {
>   va_list ap;
>   int z;
>
>   va_start(ap, dummy);
>   while( (z = va_arg(ap, int))!=0)
>   {
>     printf("== %i ==\n", z);
>   }
>   va_end(ap);
> }
>
> int main()
> {
>   doTheThing(-1, 1, 2, 3, 0);
> }
>   
I think this doesn't work because libffi doesn't support vararg
functions:
"There is no support for calling varargs functions.  This may work on
some platforms, depending on how the ABI is defined, but it is not
reliable."

Since you are on a platform where the JIT doesn't work properly, I guess
libffi's varargs
don't work either. What platform is it?

This only refers to external varargs functions, not ones you define
yourself.
It works just fine with the JIT though.

I think it would be easier if you'd debug JIT problems this way (to
avoid running into libffi
limitations in the interpreter):
 1. compile your code with -O0 to LLVM BC
 2. compile the BC to native code (using llc + assembler + linker), test
that it works (output is correct)
 3. use the JIT to run the BC, test that it works properly (output is
correct)
 4. Repeat steps 1-3 with -O1, -O2, until it fails

Once you identified at which stage the problem occurs, you can try the
instructions here to further narrow down the problem:
http://llvm.org/docs/HowToSubmitABug.html#codegen

Best regards,
--Edwin

2010/2/1 Török Edwin <edwintorok at gmail.com>
> On 02/01/2010 01:13 PM, Kristaps Straupe wrote:
> > Hello again!
> >
> > We have fetched the latest llvm sources from repository and the
> > original problem has went away. Though now we are facing a new problem
> > with interpreter on the following c code:
> >
> > --------------
> > #include <stdarg.h>
> > #include <stdio.h>
> >
> > void doTheThing(int dummy, ...)
> > {
> >   va_list ap;
> >   int z;
> >
> >   va_start(ap, dummy);
> >   while( (z = va_arg(ap, int))!=0)
> >   {
> >     printf("== %i ==\n", z);
> >   }
> >   va_end(ap);
> > }
> >
> > int main()
> > {
> >   doTheThing(-1, 1, 2, 3, 0);
> > }
> >
>
> I think this doesn't work because libffi doesn't support vararg
functions:
> "There is no support for calling varargs functions.  This may work on
> some platforms, depending on how the ABI is defined, but it is not
> reliable."
>
I don't think that's the problem. The call to doTheThing shouldn't
involve
libffi since it's not an external call, and the call to printf doesn't
involve libffi since it's a hard-coded known-varargs function. See the table
at the end of lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp for a
list of functions we trap instead of sending to libffi.

I have no idea why it's failing yet.

Nick

> Since you are on a platform where the JIT doesn't work properly, I
guess
> libffi's varargs
> don't work either. What platform is it?
>
> This only refers to external varargs functions, not ones you define
> yourself.
> It works just fine with the JIT though.
>
> I think it would be easier if you'd debug JIT problems this way (to
> avoid running into libffi
> limitations in the interpreter):
>  1. compile your code with -O0 to LLVM BC
>  2. compile the BC to native code (using llc + assembler + linker), test
> that it works (output is correct)
>  3. use the JIT to run the BC, test that it works properly (output is
> correct)
>  4. Repeat steps 1-3 with -O1, -O2, until it fails
>
> Once you identified at which stage the problem occurs, you can try the
> instructions here to further narrow down the problem:
> http://llvm.org/docs/HowToSubmitABug.html#codegen
>
> Best regards,
> --Edwin
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20100201/20dc950c/attachment.html>