search for: subexpressions

What is the simplest way to extract a matched subexpression? Eg. in perl you can do "hello world" =~ m/hello (.*)/ which would return 1(true) and set $1 to the matched subexpression "world". -- View this message in context: http://n4.nabble.com/regular-expression-submatch-tp1459146p1459146.html Sent from the R help mailing list archive at Nabble.com.

Hi all, Is there any existing pass that performs fast local common subexpression elimination? The reason I'm asking is because global common subexpression elimination (GVN or GVN-PRE) is too slow for my JIT purposes, but I see lots of value in local CSE. Thanks, Nicolas -------------- next part -------------- An HTML attachment was scrubbed... URL:

I can't get the PERL subexpression translated to R. Following, for example, B. Ripley's http://finzi.psych.upenn.edu/R/Rhelp02a/archive/58984.html I am using sub, but it looks like an ugly substitute. Assume I want to extract the first alpha part and the first numeric part, but only if they are in sequence. Do I really have to use the sub twice, first extracting the first variable, then

Hi, I currently have these two lines in my dialplan to extract different parts out of a variable and I'd like to do it in one line instead. Does anyone know how to use regular expression subexpressions in the dialplan? Outputting a comma separated list that can be sent to ARRAY() would be nice too (tried that, didn't work -- only got the first subexpression). ;extract dialed number exten => s,n,Set(dialed_num=$[ "${ARG1}" =~ "(.*)\\*" ]) ;extract user specified caller...

...where expected via my algebra and R but I have not yet done a detailed numerical comparison (so I cannot be 100% sure of my algebra). What I would like is for the output of D to look at least somewhat similar to my hand algebra. It occurred to me that if expressions could be constructed from subexpressions, I could get a more readable result (from D), as opposed to > fx2 -(invroot2pi/sigma) * (exp(-0.5 * (((x - mu)/sigma)^2)) * (0.5 * (2 * (1/sigma * (1/sigma)))) - exp(-0.5 * (((x - mu)/sigma)^2)) * (0.5 * (2 * (1/sigma * ((x - mu)/sigma)))) * (0.5 * (2 * (1/sigma * ((x - mu)/sigm...

On Mon, 29 Jan 2007, Gil Dogon wrote: > Now the problem with this code , is that the calculation of the address > mat[i][j] which is done by the (two) getelementptr instructions > is quite expensive (involving at least two multiplications and one > addition) hence it actualy should have been moved out of the inner loop. Right. > and not twice. Anyway this is just a syptom of a

We've notice that when loops are unrolled there seems to be a limit of 64 subexpressions that can be assigned to registers. In our architecture we've got a lot more registers available than just 64. Is there some parameter we can change to the loop unroller that allows more subexpressions to be assigned to a number of registers beyond 64? Phil -------------- next part ------------...

Hello. I have a problem which is quite basic for array optimization, amd I wonder whether I am missing something, but I could not find the LLVM pass that does it. Consider the following code snippet: int test() { int mat[7][7][7]; int i,j,k,sum=0; for(i=0;i<7;i++){ for(j=0;j<7;j++){ for(k=0;k<7;k++){ sum+=mat[i][j][k]^mat[i][j][k^1]; } } } return

Hello, I'm writing for a backend and have a complicated instruction bundle (3 instructions) that has to be executed like a single block (meaning: if the first instruction is executed, all three have to be executed to obtain the result, though not necessarily without other instructions in between). Unfortunately, MachineCSE gets in the way sometimes and rips it apart. Is there a way to

...x, Some y -> x + y | Some n, None | None, Some n -> n | None, None -> None Here, the expressions like 'Some x' and 'None' are patterns, which match different variants of the 'maybe int' type. 'Some x' and 'Some y' additionally bind matched subexpressions to names. For the first pattern, I chose to shadow the nullable parameters with the non- nullable matched subexpressions. More to your point, however, the analysis you're proposing seems strongly something that should be done in your language's IR prior to LLVM lowering. Several of...

I'm new to the LLVM, so please forgive what might be a silly question. I'd like to use the opt bytecode-to-bytecode optimizer, but when I try running it to do, for example, dead code elimination (-dce) or global common subexpression elimination (-gcse), nothing much seems to happen: opt -gcse -dce -o bar-opt.bc bar.bc llvm2cpp -o bar-opt.cpp bar-opt.bc

...Most of the problems are easy to fix, so I list them in here for trunk version. Also few problems in clang code were found, I don't list them in here. ---- lib/Target/X86/X86ISelLowering.cpp:11689 !DAG.isKnownNeverZero(LHS) && !DAG.isKnownNeverZero(LHS)) Note that there are identical subexpressions '!DAG.isKnownNeverZero (LHS)' to the left and to the right of the '&&' operator. The second subexpression should probably be !DAG.isKnownNeverZero(RHS)). ---- lib/Transforms/Scalar/ObjCARC.cpp:1138 void clearBottomUpPointers() {     PerPtrTopDown.clear(); } void clearTopD...

...(assuming that an optimization exists within the subset). > +1 - This sounds like a very interesting approach. I suspect it might also find > cases which are easier to hand generalize, but that's just a guess. this sounds like what my LLVM superoptimizer did: simplified expressions to subexpressions that were already present in the original expression, for example (x+y)-x -> y. Here the right-hand side "y" is a particularly simple subexpression of the original :) One big advantage is that you can process expressions very fast, typically hundreds per second. The other advanta...

an interesting problem occurs if you do interval arithmetic. void foo() { float XL, XU, Y, Z; .... call_change_rounding_mode(lower); XL = Y + Z; // lower bound call_change_rounding_mode(upper); XU = Y + Z; } Two issues here: 1) will the compiler mistakenly treat Y+Z as a common subexpression. 2) might it move the call_change_rounding_mode after the assignment to XU since it seens no

...steady.f: In subroutine `dsteady': steady.f:101: Beta = -beta ^ Expression at (^) has incorrect data type or rank for its context steady.f:101: Beta = -beta 12 Arithmetic operator at (1) must operate on two scalar (not array) subexpressions, two function invocations return ing arithmetic scalars, or a combination of both -- but the subexpression at (2) is an array steady.f:106: Beta = -beta ^ Expression at (^) has incorrect data type or rank for its context steady.f:106: Beta = -beta...

On Wed, 21 May 2008, Nicolas Capens wrote: > Thanks for the detailed explanations. I have a few remaining questions: > > Am I correct that ScalarReplAggregates is hardly more expensive than Mem2Reg > and therefore generally preferable? Right. > What would be the code quality implications of using "-dce -simplifycfg" > instead of -adce? As far as I understand the

Hallo I'm having trouble figuring out how to evaluate an expression when one of the variables in the expression is defined separately as a sub expression. Here's a simplified example mat <- expression(0, f1*s1*g1) # vector of formulae g1 <- expression(1/Tm) # expansion of the definition of g1 vals <- data.frame(f1=1, s1=.5, Tm=2) # one set of possible values for

Trying to think of a clever way to do something.... On Mips 16, the SP (stack pointer) is not a directly accessible register in most instructions. There is a way to move to and from mips 16 registers (subset of mips32) and mips32 registers. For the load/store word instructions, there are forms which implicitly take SP. However, for store/load byte and store/load halfword, there is no such

On Mon, Apr 7, 2014 at 12:09 PM, Joerg Sonnenberger <joerg at britannica.bec.de > wrote: > On Mon, Apr 07, 2014 at 08:38:58AM -0600, Richard wrote: > > Oops, meant to send this to the mailing list instead of to Reid > > privately. (Why cc the mailing list instead of just sending to the > > mailing list?) > > > > In article <CACs= >

----- Original Message ----- > From: "reed kotler" <rkotler at mips.com> > To: LLVMdev at cs.uiuc.edu > Sent: Wednesday, April 17, 2013 8:32:23 PM > Subject: [LLVMdev] optimization in presence of floating point > > an interesting problem occurs if you do interval arithmetic. > > void foo() { > float XL, XU, Y, Z; > > .... >