similar to: Call-stack and exception handling for Windows x64 JIT

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

Hi, I'm using IR and MCJIT to compile a script language. I debug it with on the fly generated .pdb files. During debugging, almost each time I step into a function, I loose information about calling function inside the visual studio callstack view or I have a bunch of pure addresses in the callstack in between the current function and the calling function, for example :

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

I've always just hacked support for this in to the various JITs (for JuliaLang, in our debuginfo.cpp file), by setting the no-frame-pointer-optim flag in the IR, then creating and populating a dummy unwind description object in the .text section, and registering that dynamically. Some day I hope to actually just register the .pdata/.xdata sections with the unwinder. PDBs are a bit different

Hello everyone, I was following the discussion, but I have to admit, that my skills aren't high enough to follow you guys. For my current exception problem, I don't have to stick around with the PECOFF format, so I used clang to don't compile to a PECOFF, but to a ELF file. Interesting, now I'm missing the functions: __cxa_allocate_exception __cxa_throw _ZTI I loaded the DLL

Hi All, We recently migrated to llvm 9 from gcc -7 and found that the stack usage is more like 5K in the below function getInfoFromDwarfSection() @ line : 1484 <https://github.com/llvm-mirror/libunwind/blob/master/src/UnwindCursor.hpp#L1484> With our analysis and found that "typename CFI_Parser<A>::PrologInfo prolog" local data is taking up almost 4K space. So we

On Mar 28, 2008, at 5:17 PM, Chuck Rose III wrote: > I was curious about the state of stack alignment on x86. I noticed > there are a few bugs outstanding on the issue. I recently added > some code which had the effect of throwing an extra function > parameter on our stack at runtime, a 4 byte pointer. > > Esp is now not 16-byte aligned, so instructions like unpcklps

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 >

Hola LLVMers, I was curious about the state of stack alignment on x86. I noticed there are a few bugs outstanding on the issue. I recently added some code which had the effect of throwing an extra function parameter on our stack at runtime, a 4 byte pointer. Esp is now not 16-byte aligned, so instructions like unpcklps xmm1, dword ptr [eps] cause grief. My AllocaInstr instructions are

I started to implement inlining of the stack probe function based on Microsoft's inlined stack probes in https://github.com/Microsoft/llvm/tree/MS. Do we know why the stack pointer cannot be updated in a loop (which results in ideal code)? I noticed that was commented in Microsoft's code. I suspect this is due to debug or unwinding information, since it is allowed on Windows x86-32. I

I am trying to run some code allocating a lot of memory and not releasing it in JIT under google-perftools. Just one function 'main' calling 'malloc'. google-perftools fails to correctly read stack when malloc is called from inside the JITted code, and as a result perftools report is wrong: address of 'main' procedure appears shifted 0x3946e1d0->0x3946e1ed and is

I am new to the LLVM, and need some help with this points. 1. how can we add special code for the Prolog/Epilog for some certain functions, this should be done with machinefunction pass, rt? 2. Basically, I want to get the function stack frame, that is the size and the initial position. I found int64_t llvm::MachineFrameInfo::getObjectSize ( int *ObjectIdx* ) const[inline] This method is

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

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

Hi all, I have the following code: [use llvm to generate ir_func() ] in side the ir_func() there's a call to a native cpp function that throws an exception. (Just imagine changing the fibonacci example and calling a native c++ func that throws inside the fibonacci body) I can't seem to catch "foreign" exception or any exception using the following pseudo code: try { // cast

Hey guys, I'm working on a bug for x86-64 in LLVM 2.9. Well, it's actually two issues. The assembly generated for large stack offsets has an overflow; And, once the overflow is fixed, the displacement is too large for GNU ld to handle it. void fool( int long n ) { double w[268435600]; double z[268435600]; unsigned long i; for ( i = 0; i < n; i++ ) { w[i] = 1.0; z[i] =

I've run into a problem that I'm trying to figure out how to address and would welcome ideas and feedback. Today, the vectorizer will nicely vectorize loops using the widest legal vector type for the target. On a reasonable recent machine, this will often end up using AVX2 registers which are 32 bytes wide. If during register allocation, we decide to spill one of these registers, we

Hello, it seems the Prolog/Epilog insertion does not correctly align stack for me. Consider the PEI::calculateFrameObjectOffsets method. It only aligns the stack if FFI->hasCalls() is true. The only place where MachineFrameInfo::setHasCalls is invoked is PEI::saveCallerSavedRegisters and the value 'true' is only passed when there are instructions with opcodes equal

On Sep 26, 2011, at 12:02 PM, Cameron McInally wrote: > > Here's one of the offending instructions produced by 2.9: > > movsd -2147482472(%rsp), %xmm0 > > Fixing the displacement overflow is pretty easy. It's just a matter of changing a few variable types in LLVM from unsigned to uint64_t in the functions that calculate the stack offsets. The real trouble I'm

Current set of patches for my work on segmented stacks. Go / dragonegg seems to work when using this code (I still haven't run any rigorous tests yet). Thanks! (Also on https://github.com/sanjoy/LLVM/tree/segmented-stacks) -- Sanjoy Das http://playingwithpointers.com -------------- next part -------------- A non-text attachment was scrubbed... Name: