search for: powe

Hi, Current llvm-gcc cannot emit llvm intrinsic function like llvm.pow.* and llvm.sin.* For example: double foo(double x, double y) { return pow(x,y); } will compiled into ll: define double @foo(double %x, double %y) { %tmp3 = tail call double @pow( double %x, double %y ) ret double %tmp3 } This is not consistent with llvm language reference. -------------- next part -------------- An

...logic. >>>> But I am not quite sure for which parts of LLVM should I replace built-in >>>> pow with another efficient pow implementation. Any comments and feedback >>>> are appreciated. Thanks! >>> In Numba, we have decided to optimize some usages of the power function >>> in our own front-end, so that LLVM IR gets an already optimized form, >>> as we have found that otherwise LLVM may miss some optimization >>> opportunities. YMMV. >> It seems to me that it would be more interesting to gather these misoptimization and f...

...y. Sure. But now the question is the llvm-gcc will not emit llvm.pow.* anytime. Also, don't forget that the llvm intrinsics > don't set errno, so using them is only valid on systems/for languages > for which errno is ignored. That said, llvm.pow.* is for raising > to an integer power, and here you raise to a double power. I don't understand. why we can't use llvm.pow.f64 for double power? Sheng. Ciao, > > Duncan. > -------------- next part -------------- An HTML attachment was scrubbed... URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/2007...

...part, I am clear for the logic. >> But I am not quite sure for which parts of LLVM should I replace built-in >> pow with another efficient pow implementation. Any comments and feedback >> are appreciated. Thanks! > > In Numba, we have decided to optimize some usages of the power function > in our own front-end, so that LLVM IR gets an already optimized form, > as we have found that otherwise LLVM may miss some optimization > opportunities. YMMV. It seems to me that it would be more interesting to gather these misoptimization and fix LLVM to catch them. > &g...

...e doesn't say anywhere that you *have* to use llvm.pow.* rather than pow from the C library. Also, don't forget that the llvm intrinsics don't set errno, so using them is only valid on systems/for languages for which errno is ignored. That said, llvm.pow.* is for raising to an integer power, and here you raise to a double power. Ciao, Duncan.

Hi, I want an efficient way to implement function pow in LLVM instead of invoking pow() math built-in. For algorithm part, I am clear for the logic. But I am not quite sure for which parts of LLVM should I replace built-in pow with another efficient pow implementation. Any comments and feedback are appreciated. Thanks! -- Wei Ding -------------- next part -------------- An HTML attachment was

The transformation in LibCallSimplifier::replacePowWithSqrt with respect to -Inf uses a select instruction, which based on the observed behaviour, incorporates the side effects of the unchosen branch. This means that (for pow) a call to sqrt(-Inf) is materialized. Such a call is specified as having a domain error (C17 subclause 7.12.7.5) since the operand is less than zero. Contrast this with

...te: > On Wed, 5 Jul 2000, halvorsen wrote: > > > Hola! > > > > I have the following simple function: > > > > > testcar > > function(pow){ > > ob <- glm(Pound~CG+Age+Vage,data=car,weights=No, > > subset=No>0,family=quasi(link=power(pow),var=mu^2)) > > > > deviance(ob) > > } > > But trying to run it gives: > > > > > testcar(1/2) > > Error in power(pow) : Object "pow" not found > > 'pow' isn't found because quasi() is looking for it in a strang...

I've been working on some basic library call optimizations, the SimplifyLibCalls pass (lib/Transforms/IPO/SimplifyLibCalls.cpp). Tonight I conjured up a list of the potential libcall simplifications that could be done. There's a lot of them. I could use some help if anyone wants to pitch in. The individual optimizations are self-contained and fairly straight forward to write. They range

Sorry - I misread your example and the problem. I see now where LibCallSimplifier creates the select...but we are immediately erasing that select with the code from the godbolt example. Does the real motivating case have no uses of the pow() result value? On Mon, Sep 14, 2020 at 1:03 PM Sanjay Patel <spatel at rotateright.com> wrote: > Yes, I mean just bail out on the transform in >

On Mon, Sep 14, 2020 at 12:45 PM Sanjay Patel <spatel at rotateright.com> wrote: > Yes, that looks like a bug. The transform is ok in general for negative > numbers, but -Inf is a special-case for pow(), right? > If so, we probably need an extra check of the input with > "isKnownNeverInfinity()". > There is an extra check there already, but it uses

...But I am not quite sure for which parts of LLVM should I replace built-in >>>>>> pow with another efficient pow implementation. Any comments and feedback >>>>>> are appreciated. Thanks! >>>>> In Numba, we have decided to optimize some usages of the power function >>>>> in our own front-end, so that LLVM IR gets an already optimized form, >>>>> as we have found that otherwise LLVM may miss some optimization >>>>> opportunities. YMMV. >>>> It seems to me that it would be more interesting to ga...

Hola! I have the following simple function: > testcar function(pow){ ob <- glm(Pound~CG+Age+Vage,data=car,weights=No, subset=No>0,family=quasi(link=power(pow),var=mu^2)) deviance(ob) } But trying to run it gives: > testcar(1/2) Error in power(pow) : Object "pow" not found I have tried to use debug on testcar, but what I can find out is only that pow is invisible from within glm. Is there a way to find in which environment...

Hi, > Sure. But now the question is the llvm-gcc will not emit llvm.pow.* anytime. indeed there seems to be no code in llvm-gcc to do so, though there is code for raising to an integer power (in llvm-convert). Please feel free to investigate and add some. Presumably it should turn gcc's BUILT_IN_POW into llvm.pow.*. That said, as far as I can see the C front-end doesn't generate BUILT_IN_POW at all, though the fortran and java front-ends do. It is true that the gcc constant...

Suppose I have a square matrix P P <- matrix(c(.3,.7, .7, .3), ncol=2) I know that > P * P Returns the element by element product, whereas > P%*%P Returns the matrix product. Now, P^2 also returns the element by element product. But, is there a slick way to write P %*% P %*% P Obviously, P^3 does not return the result I expect. Thanks, Harold [[alternative HTML version

Hi, It looks like SimplifyLibCalls has a tendency to emit calls to libm functions without checking with TLI whether these calls are available. For example, PowOpt has this code: struct PowOpt : public UnsafeFPLibCallOptimization { PowOpt(bool UnsafeFPShrink) : UnsafeFPLibCallOptimization(UnsafeFPShrink) {} virtual Value *callOptimizer(Function *Callee, CallInst *CI, IRBuilder<> &B)

OK, I have made a little search about this "problem" that apparently occurs only on Windows platform... (but I am sure most of you are already aware of it): the slow down is due to the adoption of a different algorithm for pow in mingw 3.x. This is motivated by some other changes in mingw. Here is a quote of Danny Smith that did this change: >When mingw changed default FPU settings

Hi everyone, I am trying to install colorspace (needed as part of my favourite ggplot2) on R v 2.7.0 running under ubuntu 7.04. The package is provided as source files and the compilation fails as below. I suspect this might be a problem with gcc v3/v4 incompatibility (or anything else), but I don't really know how to resolve it. Any advice will be appreciated - or perhaps somebody has got

I set up a new project on my computer and created the development link. I am very new to Ruby and just need help in determining where to look to solve the issues I am having getting access to the project. Here are the errors I get when trying to visit my application: Bundler::GemNotFound: Could not find rake-0.9.2.2 in any of the sources

PS: It is possible that the C front-end doesn't need to explicitly produce BUILT_IN_POW because it is auto-synthesized somehow from a call to "pow". I wouldn't know. One way to find out is to compile a testcase and rummage around inside the gcc trees when they hit llvm-convert.