llvm dev - Jan 2010 - [LLVMdev] Redefining function

Hi Duncan,
> I couldn't find the solution to my problem (if it has one) in the
mailing
>> list or the source code. The problem is: how can I redefine a function
>> that's been called already by some other function?
>>
>
> why do you want to do this?
>
To implement something that is common in Lisp. Suppose I have a program that
is running and can't be stopped or the cost being stoped is prohibitive. If
I find a better way to run an algorithm, I'd like to update the running
program non-stopping.


 Suppose I have 3 files, all compiled to bytecode through llvm-gcc (I
think
> it could be clang instead).
>
> File1.c:
> void do_print() { print(); }
>
> File2.c:
> void print() { printf("File2.c\n"); }
>
> File3.c:
> void print() { printf("File3.c\n"); }
>
The solution in C is to give the version in File2 a weak linkage
type,
> for example using gcc's "weak" attribute.  You then link all
three files
> together, and the weak print in File2 will be magically replaced with the
> non-weak print in File3.

Never heard of it before. After a quick reading, it sounds OK. Keeping the
rest of the file, changed the attribute and this section:

  func = EE->FindFunctionNamed ("do_print");
  EE->runFunction(func, std::vector<GenericValue> ());
  Linker::LinkModules(main_file, print2, &ErrorMessage);
  EE->runFunction(func, std::vector<GenericValue> ());

And now I get this error before the second runFunction:

While deleting: void ()* %print
An asserting value handle still pointed to this value!
UNREACHABLE executed at /home/miranda/llvm-2.6/lib/VMCore/Value.cpp:492!

I suppose that's because "do_print" was already called. By the
way, it seems
like weak attribute is only supported for ELF and a.out. Maybe not the
better solution.

  //swap the definition of the function "print" from the one in
File2.c to
> File3.c
>  swap (file1, file2, file3);
>
If all the functions are in the same module, then you can
use
> FunctionA->replaceAllUsesWith(FunctionB) if they have the same
> type.
>
Sorry I didn't see that function before. But, when I tried that (pastebin
code: http://pastebin.com/m2485ae4f), it still doesn't print as supposed. It
calls only the first function printing
File2.c
File2.c

Maybe that works when the functions haven't been called before. Am I using
the wrong way or had to do something before?

Thanks,

Miranda
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20100130/c29ad19c/attachment.html>

Conrado Miranda wrote:
> To implement something that is common in Lisp. Suppose I have a program
> that is running and can't be stopped or the cost being stoped is
> prohibitive. If I find a better way to run an algorithm, I'd like to
> update the running program non-stopping.
The way I do this in Pure is to always call global functions in an
indirect fashion, using an internal global variable which holds the
current function pointer. When a function definition gets updated, the
Pure interpreter just jits the new function, changes the global variable
accordingly, and frees the old code.

Compared to Duncan's suggestion, this has the advantage that you only
have to recompile the function which was changed. AFAICT, if you use
replaceAllUsesWith, then the changes ripple through so that you might
end up re-jiting most of your program.

Albert

-- 
Dr. Albert Gr"af
Dept. of Music-Informatics, University of Mainz, Germany
Email:  Dr.Graef at t-online.de, ag at muwiinfa.geschichte.uni-mainz.de
WWW:    http://www.musikinformatik.uni-mainz.de/ag

Albert Graef wrote:
> The way I do this in Pure is to always call global functions in an
> indirect fashion, using an internal global variable which holds the
> current function pointer. When a function definition gets updated, the
> Pure interpreter just jits the new function, changes the global variable
> accordingly, and frees the old code.
>
> Compared to Duncan's suggestion, this has the advantage that you only
> have to recompile the function which was changed. AFAICT, if you use
> replaceAllUsesWith, then the changes ripple through so that you might
> end up re-jiting most of your program.
>
Thought of that before, but I was trying to do it more elegantly and
transparent to the program (which is being write in C/C++). Maybe going back
to that.

Thank you both for the quick replies.

Miranda

PS:
If it's any help, got the svn version and, while running the program, got
this:
The JIT doesn't know how to handle a RAUW on a value it has emitted.
UNREACHABLE executed at
/home/conrado/engines/llvm/lib/ExecutionEngine/JIT/JITEmitter.cpp:1542!

I looked at the function and it's a dummy function. Just looking forward to
see that corrected.
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20100131/a5097a2a/attachment.html>