similar to: [LLVMdev] Why google-perftools fails on the JITted code?

On Jun 18, 2010, at 3:29 AM, Yuri wrote: > Now I see that JITted code doesn't have standard prolog, on x86 each > procedure instead begins with 'sub $0x4,%esp'. > > Is there an option to make JIT generate regular prologs? Try turning off frame pointer elimination. On the llc command line, this is -disable-fp-elim -Chris > > Yuri >

On Sat, Jun 19, 2010 at 4:35 AM, Chris Lattner <clattner at apple.com> wrote: > > On Jun 18, 2010, at 3:29 AM, Yuri wrote: > >> Now I see that JITted code doesn't have standard prolog, on x86 each >> procedure instead begins with 'sub    $0x4,%esp'. >> >> Is there an option to make JIT generate regular prologs? > > Try turning off frame

Now I see that JITted code doesn't have standard prolog, on x86 each procedure instead begins with 'sub $0x4,%esp'. Is there an option to make JIT generate regular prologs? Yuri

This new option (--jit-emit-debug-function-range) will allow to output function information for memory ranges that functions occupy in memory while they run in JIT. File format generated is like this: ... 0x5000000 0x5001000 function_name_is_here ... This feature is useful for external tools like valgrind and google-perftools to profile the code when it is run in JIT. Particularly

This new option will allow to output function information in the same format as addr2line from binutils emits: ... 0xABCDEF01 T function_name_is_here ... This feature is useful to profile the code when it is run in JIT by external tools like valgrind and google-perftools. For example, google-perftools runs addr2line on executable and uses the resulting file to resolve memory addresses to

I have this problem: google-perftools fails to detect stack for the code run under JIT called through C++ api from my program. It shows in profile like all program is one block with the name _init. I clearly do set the option NoFramePointerElim and I do see how it makes a difference in stack frame under gdb. When running some code in JIT in lli (with option -disable-fp-elim) google perftools

On 06/19/2010 14:03, Yuri wrote: > This new option (--jit-emit-debug-function-range) will allow to output > function information for memory ranges that functions occupy in memory > while they run in JIT. File format generated is like this: > ... > 0x5000000 0x5001000 function_name_is_here > ... > > This feature is useful for external tools like valgrind and >

Have you found http://llvm.org/docs/DebuggingJITedCode.html? The JIT already has support for something like this for gdb's benefit. Perftools and valgrind just don't know how to find it yet. On Sat, Jun 19, 2010 at 2:03 PM, Yuri <yuri at rawbw.com> wrote: > This new option (--jit-emit-debug-function-range) will allow to output > function information for memory ranges that

I have this situation when the same code SEGVs in JIT with option -disable-fp-elim and works fine without it. How can this possibly happen? Is it possible that there is a bug in JIT that stack isn't properly lowered for local variables when prologs are present? Or maybe JIT can accidentally use ebp for some values when it's supposed to be only used by frame pointer value. Stack (see

On Jun 22, 2010, at 4:18 PM, Yuri wrote: > On 06/19/2010 14:03, Yuri wrote: >> This new option (--jit-emit-debug-function-range) will allow to output >> function information for memory ranges that functions occupy in memory >> while they run in JIT. File format generated is like this: >> ... >> 0x5000000 0x5001000 function_name_is_here >> ... >>

On 06/19/2010 14:14, Jeffrey Yasskin wrote: > Have you found http://llvm.org/docs/DebuggingJITedCode.html? The JIT > already has support for something like this for gdb's benefit Yes, I saw it and tried it. -jit-emit-debug generates ELF image in memory with debug info. Another option -jit-emit-debug-to-disk creates .o ELF files with debug info, one per function. If there are thousands

You said this is on 32-bit x86? My understanding is that in that case, gdb will use ebp/esp to unwind the stack and doesn't need dwarf. It may have different behavior on FreeBSD if frame pointers are normally omitted on that platform. gdb ignores them on Linux x86_64 because they are generally omitted. This might actually be the best explanation for your symptoms, since this is what a gdb

In order to avoid a cross post, the following background quote is from SCIENTIFIC-LINUX-USERS at fnal.gov: <quote> On Wed, Feb 9, 2011 at 11:27 AM, Ewan Mac Mahon <ewan at macmahon.me.uk> wrote: > > I'm a little bit hazy on the details, but there are some slides from the > meeting here[1]: >

Hi James, I also think that refactoring the code generation part is a great idea. That code is very complicated and difficult to maintain. I’ve wanted to rewrite that code for a long time, but just have never got to it. There are quite a few edge cases to handle (at least in the current code). I’ll take a deeper look at your patch. The abstractions that you mention, Stage and Block, are good

Historically? I implemented support for exceptions back in LLVM 3.3, before LLVM had an implementation of a Windows unwinder. Currently? As recent as LLVM 4.0, I don't think the JIT was fully capable of handling COFF files, and LLVM wouldn't emit the correct sections (with the COFF-formatted unwind tables) when used in ELF mode. The prolog is known to be standard since Julia disables FPO

On Sat, Jun 19, 2010 at 8:53 PM, Yuri <yuri at rawbw.com> wrote: > I have followed http://llvm.org/docs/DebuggingJITedCode.html, used the > latest release gdb-7.1 (from March 18, 2010) and got this stack: > > (gdb) bt > #0  0x35532156 in ?? () > #1  0x355320f8 in ?? () > #2  0x35532098 in ?? () > #3  0x3553202e in ?? () > #4  0x34a5661a in ?? () > #5  0x349d9bd9

Hi, I use LLVM MCJIT extensively and one of the sore spots is debugging. We lose stack information if we crash during execution of one of our JIT functions. I spent some time to understand Windows x64 stack/exception handling and was able to hardcode support for a single JIT function and was able to maintain the call stack correctly. However it requires knowledge of the prolog of the function to

How/where are function prologs and epilogs generated, is it bespoke C++ code or TableGen generated ? If someone could point me in the right direction please. Many thanks in advance, Aaron -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20090409/fb3336e4/attachment.html>

When I try running simple example with exceptions through JIT I get this output: terminate called after throwing an instance of 'E*' Why exceptions don't work in JIT and what it takes to make them work? Yuri --- e.C --- #include <stdio.h> #include <stdlib.h> class E { }; void xmain() { try { throw new E; } catch (E *e) { printf("caught!\n");

This is https://bugs.llvm.org/show_bug.cgi?id=24233. I don't think there's been any movement on it for a while. I don't *think* it should be hard, but I've never really pushed on it. On Tue, Jan 2, 2018 at 3:57 PM, Jason via llvm-dev <llvm-dev at lists.llvm.org> wrote: > Hi, I use LLVM MCJIT extensively and one of the sore spots is debugging. > We lose stack