similar to: [LLVMdev] Re ducing LLVM's memory usage

Hi Vitaly C. wrote: > > Is there are simple way of cleaning the used memory without destroying > everything (unloading the ExecutionEngine, freeing the module, calling > llvm_shutdown) ? Ideally I would like something which brings everything to > the state just after I created the JIT engine for the first time. > I've tried to run the Fibonacci example with Valgrind

Hi, I would like to generate an LLVM bitcode file that contains all the types and functions declared in a header file. For example, the following code should make the llvm compiler put all type information contained in stdio.h in the resulting bitcode file. #include <stdio.h> int main() { return 0; } Unfortunately, when compiled with "llvm-gcc -g -emit-llvm -c test.c", the

Hello Vitaly, Clang supports LLVM Bitcode formatted precompiled headers if that is what you are looking for. LLVM-GCC might be a different story though. Also note that these headers will be different from one operating system to the next. If you're looking for something portable, test out my wrapper at http://sourceforge.net/projects/llvmlibc/ in the SVN repo. --Sam ----- Original

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA1 I've been reading the headers and http://llvm.org/releases/2.1/docs/ProgrammersManual.html and I'm still confused about a pretty fundamental point... who is expected to clean up various objects when we're finished with them, and when? Let's say I've created a module, retrieved a bunch of types, created a function, a basic block,

I'm curious about the design rationale for how ManagedStatic instances are cleaned up, and I'm hoping someone can shed some light on it. Currently, ManagedStatic objects are cleaned up when llvm_shutdown() traverses the global list of initialized objects and calls destroy() on each. This leads to two questions: 1. An assertion enforces that the objects are deleted in reverse order of

Hi, We have been investigating an issue when running LTO with our proprietary linker, which links against libLTO dynamically. The issue is that when we pass -time-passes via the lto_codegen_debug_options function in the LTO C API, no time information is produced during compilation. The reason for this is that time information is stored in state owned by a ManagedStatic instance, and is only

Right, I'm suggesting we keep llvm_shutdown() for users who want this control, but also destroy still-live ManagedStatic instances if llvm_shutdown() is not called. This helps in the case where there is not a clear time when llvm_shutdown() can be called, especially given that LLVM cannot be resurrected in the same process due to current limitations in the pass registry, and perhaps

Chris, I'm using a llvm_shutdown_obj object and it calls llvm_shutdown when I delete it. Do I need to call llvm_shutdown() again afterwards? It looks to me like the static object is being created after my program exits main(). From: Chris Lattner [mailto:clattner at apple.com] Sent: Friday, January 13, 2012 10:11 AM To: Villmow, Micah Cc: LLVM Developers Mailing List Subject: Re: [LLVMdev]

> From: Armin Steinhoff [mailto:armin at steinhoff.de] > Subject: Re: [LLVMdev] New JIT APIs > is >  delete EE;   // execution engine >  llvm_shutdown(); > sufficient ? AFAICT, llvm_shutdown() must not be called unless you reach a point where LLVM will not be used again by the process (e.g., termination), as it destroys statically allocated objects. We delete the

2017-05-02 8:42 GMT-07:00 Duncan P. N. Exon Smith <dexonsmith at apple.com>: > +Teresa, Mehdi > > On May 2, 2017, at 08:31, James Henderson <jh7370.2008 at my.bristol.ac.uk> > wrote: > > Hi, > > We have been investigating an issue when running LTO with our proprietary > linker, which links against libLTO dynamically. The issue is that when we > pass

Hey Daniel, thanks for the response. > I believe all you need to do is call llvm::llvm_shutdown(). > I am not sure that this is what I need. When and how should I call llvm_shutdown()? After the FunctionPassManager is done, the calling ModulePass still performs quite a few actions on the transformed code and also calls the FunctionPassManager on different functions. However, I need

Introduction ============ `SROA' is an early stage pass running at the very beginning of the pipeline in `-O{1,2,3}'. Greg Bedwell's report from his DExTer tool shows SROA on function as one of the major culprits of Debug Info loss. With debugify-each partially done I tried testing this on the amalgamated sqlite source. The steps are as follows: ,---- | # generate

> > > `SROA' is an early stage pass running at the very beginning of the > pipeline in `-O{1,2,3}'. Greg Bedwell's report from his DExTer tool > shows SROA on function as one of the major culprits of Debug Info > loss. > > The methodology I used is with the opt-bisect-limit option on clang, so it's not strictly the case that the results presented

Hi! I am trying to work out the code to get a Fibonacci sequence, using the while() loop and only one variable. And I can't figure it out. Fibonacci<-c(1,1) while (max(Fibonacci)<500){ Fibonacci<-c(Fibonacci, (max(Fibonacci) + ?(Fibanacci))) } How can I tell R to take the value one before the max value? (Without defining another variable) (Probably super easy... I am a

Hello everybody, I have sucessfully compiled LLVM with CMAKE generator "Visual Studio 9 2008 Win64" (OS Windows 7). -But when I run the Fibonacci example program in "release" mode, I get a crash with this visual studio popup message : Microsoft Visual Studio C Runtime Library has detected a fatal error in Fibonacci.exe. -Here is the visual studio output:

Hello everybody, is it somehow possible to get information about what passes were run in what order or timing analysis of passes *without* using opt? I am implementing a ModulePass that at some point creates a FunctionPassManager which runs several passes, but I cannot figure a way to output the same information as when running a command line tool as described in "Writing an LLVM

FYI, I have confirmed it works on VS10SP1 with x64|Release. E:\llvm\build\cmake-x64-vs10>bin\Release\Fibonacci.exe 24 verifying... OK We just constructed this LLVM module: --------- ; ModuleID = 'test' (snip) --------- starting fibonacci(24) with JIT... Result: 46368 ...Takumi 2011/8/11 <gleizesd at gmail.com>: > Hello everybody, > > I have sucessfully compiled LLVM

Hola LLVMers, I'm getting a crash when using ConstantFP::get. I can repro it by adding one line to the Fibonacci example program: int main(int argc, char **argv) { int n = argc > 1 ? atol(argv[1]) : 24; // Create some module to put our function into it. Module *M = new Module("test"); // We are about to create the "fib" function: Function

It's in debug. I'm having a look at the assembler it's producing right now and it's definitely a little odd for what should be a simple assignment in zeroSignificand. ________________________________ From: llvmdev-bounces at cs.uiuc.edu [mailto:llvmdev-bounces at cs.uiuc.edu] On Behalf Of Dale Johannesen Sent: Wednesday, September 05, 2007 2:39 PM To: LLVM Developers Mailing

Hi Ralf, I believe all you need to do is call llvm::llvm_shutdown(). - Daniel On Sun, Jul 26, 2009 at 11:51 AM, Ralf Karrenberg<Ralf.Karrenberg at gmx.de> wrote: > Hello everybody, > > is it somehow possible to get information about what passes were run in > what order  or timing analysis of passes *without* using opt? > I am implementing a ModulePass that at some point