How to debug LLVM3.2 Plugin Assertion error

1
votes

I am porting an LLVM plugin (LLFI) written for LLVM 2.9 to the latest version of LLVM/Clang.

When testing my plugin with an assertions enabled build of LLVM3.2 I get the following error:

opt: /home/kzvr/ubc/llfi/llvm3/llvmsrc/lib/IR/Instructions.cpp:281: 
 void llvm::CallInst::init(llvm::Value*, llvm::ArrayRef<llvm::Value*>, 
 const llvm::Twine&): Assertion `(i >= FTy->getNumParams() || 
 FTy->getParamType(i) == Args[i]->getType()) && "Calling a function with a bad
 signature!"' failed.
0  opt             0x00000000017931a6 llvm::sys::PrintStackTrace(_IO_FILE*) + 38
1  opt             0x0000000001793423
2  opt             0x0000000001792e7b
3  libpthread.so.0 0x00007f0c0279fff0
4  libc.so.6       0x00007f0c018a91b5 gsignal + 53
5  libc.so.6       0x00007f0c018abfc0 abort + 384
6  libc.so.6       0x00007f0c018a2301 __assert_fail + 241
7  opt             0x00000000016e78c4 llvm::CallInst::init(llvm::Value*, llvm::ArrayRef<llvm::Value*>, llvm::Twine const&) + 402
8  LLFI.so         0x00007f0c0165adcb
9  LLFI.so         0x00007f0c0165aa83
10 LLFI.so         0x00007f0c016581c5
11 opt             0x000000000171c02c llvm::FPPassManager::doFinalization(llvm::Module&) + 88
12 opt             0x000000000171c449 llvm::MPPassManager::runOnModule(llvm::Module&) + 1013
13 opt             0x000000000171c8a6 llvm::PassManagerImpl::run(llvm::Module&) + 254
14 opt             0x000000000171cc01 llvm::PassManager::run(llvm::Module&) + 39
15 opt             0x000000000087a089 main + 5591
16 libc.so.6       0x00007f0c01895c8d __libc_start_main + 253
17 opt             0x000000000086bf59

In the plugin code I have many calls to llvm::CallInst::Create, which, based on the above, I believe at least one of which is performed incorrectly. They pretty much all look like this:

ArrayRef<Value*> arrayArgs(args);
Instruction* callInst = CallInst::Create( injectFunc, arrayArgs, fiName, insertInst);

where args is an std::vector, injectFunc is an llvm::Constant*, fiName is an std::string, and insertInst is an llvm::Instruction*

The problem is, as an LLVM newbie, I dont know how to narrow my bughunt down from this point. So I have a few questions:

  1. How can I find which call to CallInst::Create is the one that causes CallInst::init to fail the assertion?
  2. Where is the documentation that explains the proper usage of the CallInst class? Google searches yield auto-generated docs of the source code, which I have already pored over to no avail.
  3. The only difference between the 2.9 and 3.2 version of this plugin (as far as CallInst goes), is the replacement of passing std::vector iterators to CallInst::create, with passing an ArrayRef constructed from the std::vector. Am I constructing the ArrayRef from the Vector improperly?

Thanks in advance for any help, I hope this question isn't too vague.

1
c++llvmclang

1 Answers

6
votes

The best tip on how to debug an LLVM assertion error - the question in the title - is to read the code of the assertion :)

The message - "Calling a function with a bad signature!" - is a little ambiguous, but looking at the actual assertion condition (which failed) you can see what the problem is:

i >= FTy->getNumParams() ||  FTy->getParamType(i) == Args[i]->getType()

So you either provide too many arguments, or one of your arguments has a different type from what the function expects. You can also look at the assertion location, Instructions.cpp line 281, to see the surrounding code for context.

To solve the issue, I'd start with looking at what, exactly, the function type is (a simple way is just to invoke ->dump() on the function or the function type, it will print it to stdout). Then I'll compare these types to the types I send to the CallInst (->dump() will work there as well). Also, verify the number of arguments against the expected number of parameters.

Regarding your remaining questions:

  1. Why not just use standard programming practices to locate the bad line?
    • e.g. comment some lines out, or add prints between lines, or just launch a debugger and see which line fails
  2. Looking at the source code (at both the implementation and the comments) is usually my preferred way of finding how to use these sorts of functions. In any case, your usage seems fine.
  3. You are not constructing an ArrayRef from the Vector improperly, only redundantly: there's an implicit conversion from an std::vector to an ArrayRef, so you can just pass your args vector as the 2nd argument. Your usage is correct, though, it's not the cause of the assertion failure.