llvm-svn: 90691

integers that are constant except for a single bit (the same n-th bit in each).

llvm-svn: 90646

folding a load from constant.

llvm-svn: 90545

that I'm working on.  This is manifesting as a miscompile of 255.vortex
on some targets.  No check lines yet because it fails.

llvm-svn: 90520

llvm-svn: 90408

llvm-svn: 90380

llvm-svn: 90369

per Chris' comments.  Adjust testcases to match.

llvm-svn: 90304

llvm-svn: 90293

llvm-svn: 90292

llvm-svn: 90291

llvm-svn: 90290

llvm-svn: 90216

llvm-svn: 90212

precisely, which prevents us from infinitely peeling the loop.

llvm-svn: 90211

llvm-svn: 90112

This permits the devirtualization of llvm.org/PR3100#c9 when compiled by clang.

llvm-svn: 90099

fix bugs exposed by the tests.  Testcases from Alastair Lynn!

llvm-svn: 90056

llvm-svn: 90049

void test(int N, double* G) {
  long j;
  for (j = 1; j < N - 1; j++)
      G[j] = G[j] + G[j+1] + G[j-1];
}

which we now compile to one load in the loop:

LBB1_2:                                                     ## %bb
	movsd	16(%rsi,%rax,8), %xmm2
	incq	%rdx
	addsd	%xmm2, %xmm1
	addsd	%xmm1, %xmm0
	movapd	%xmm2, %xmm1
	movsd	%xmm0, 8(%rsi,%rax,8)
	incq	%rax
	cmpq	%rcx, %rax
	jne	LBB1_2

instead of:

LBB1_2:                                                     ## %bb
	movsd	8(%rsi,%rax,8), %xmm0
	addsd	16(%rsi,%rax,8), %xmm0
	addsd	(%rsi,%rax,8), %xmm0
	movsd	%xmm0, 8(%rsi,%rax,8)
	incq	%rax
	cmpq	%rcx, %rax
	jne	LBB1_2

llvm-svn: 90048

void test9(int N, double* G) {
  long j;
  for (j = 1; j < N - 1; j++)
      G[j+1] = G[j] + G[j+1];
}

llvm-svn: 90047

llvm-svn: 90046

PR5574.

llvm-svn: 90045

handle cases like this:
void test(int N, double* G) {
  long j;
  for (j = 1; j < N - 1; j++)
      G[j+1] = G[j] + G[j+1];
}

where G[1] isn't live into the loop.

llvm-svn: 90041

way that getUnderlyingObject does it. 

This fixes the 'DecomposeGEPExpression and getUnderlyingObject disagree!' 
assertion on sqlite3.

llvm-svn: 90038

to inform GVN about the newly inserted values.  This fixes 
PR5631.

llvm-svn: 90022

llvm-svn: 90014

translation of add with immediate.  This allows us
to optimize this function:

void test(int N, double* G) {
  long j;
  G[1] = 1;
    for (j = 1; j < N - 1; j++)
        G[j+1] = G[j] + G[j+1];
}

to only do one load every iteration of the loop.

llvm-svn: 90013

add two simple test cases we now optimize (to one load in the loop each) and one we don't (corresponding to the fixme I added yesterday).

llvm-svn: 90012

array indexes.  The "complex" case of SRoA still handles them, and correctly.

This fixes a weirdness where we'd correctly avoid transforming A[0][42] if
the 42 was too large, but we'd only do it if it was one gep, not two separate
ones.

llvm-svn: 90007

llvm-svn: 90006

where it is not available.  It's unclear how to get this inserted 
computation into GVN's scalar availability sets, Owen, help? :)

llvm-svn: 89997

llvm-svn: 89996

llvm-svn: 89995

llvm-svn: 89994

llvm-svn: 89993

translation done by memdep, and reenable gep translation 
again.

llvm-svn: 89992

llvm-svn: 89991

llvm-svn: 89990

llvm-svn: 89985