Commits · d76d71a29136dcfd0a80a6b6a52177071408e3b5 · Roger Ferrer / llvm-epi-0.8

May 09, 2009
- Oops. Don't forget to align single bb loops. · 9085126b
  Evan Cheng authored May 09, 2009
```
llvm-svn: 71363
```
  9085126b
- Enable loop bb placement optimization. · 51fa9c71
  Evan Cheng authored May 08, 2009
```
llvm-svn: 71291
```
  51fa9c71
May 08, 2009

Don't align loop header unless the loop back edge is below the header. · 6e9959e3
Evan Cheng authored May 08, 2009
```
llvm-svn: 71242
```
6e9959e3
Reverse branch condition only when there is a conditional branch. · 5b9b33bc
Evan Cheng authored May 08, 2009
```
llvm-svn: 71214
```
5b9b33bc
Add explicit braces to disambiguate nested if/else. Removes a warning. · b873ed67
Nick Lewycky authored May 08, 2009
```
llvm-svn: 71211
```
b873ed67

Optimize code placement in loop to eliminate unconditional branches or move... · 2fa28110

Evan Cheng authored May 08, 2009

Optimize code placement in loop to eliminate unconditional branches or move unconditional branch to the outside of the loop. e.g.

///       A:                                                                                                                                                                 
///       ...                                                                                                                                                                
///       <fallthrough to B>                                                                                                                                                 
///                                                                                                                                                                          
///       B:  --> loop header                                                                                                                                                
///       ...                                                                                                                                                                
///       jcc <cond> C, [exit]                                                                                                                                               
///                                                                                                                                                                          
///       C:                                                                                                                                                                 
///       ...                                                                                                                                                                
///       jmp B                                                                                                                                                              
///                                                                                                                                                                          
/// ==>                                                                                                                                                                      
///                                                                                                                                                                          
///       A:                                                                                                                                                                 
///       ...                                                                                                                                                                
///       jmp B                                                                                                                                                              
///                                                                                                                                                                          
///       C:  --> new loop header                                                                                                                                            
///       ...                                                                                                                                                                
///       <fallthough to B>                                                                                                                                                  
///                                                                                                                                                                          
///       B:                                                                                                                                                                 
///       ...                                                                                                                                                                
///       jcc <cond> C, [exit] 

llvm-svn: 71209

2fa28110

May 07, 2009
- Code refactoring. · 143bae5d
  Evan Cheng authored May 07, 2009
```
llvm-svn: 71151
```
  143bae5d
- Rename "loop aligner" pass to "code placement optimization" pass. · f356a89e
  Evan Cheng authored May 07, 2009
```
llvm-svn: 71150
```
  f356a89e
Nov 27, 2008
- Avoid inserting noop's in the middle of a loop. · 37611437
  Evan Cheng authored Nov 27, 2008
```
llvm-svn: 60141
```
  37611437
Oct 06, 2008
- Remove unncessary isDeclaration() checks. · ab379c90
  Devang Patel authored Oct 06, 2008
```
llvm-svn: 57179
```
  ab379c90
Oct 02, 2008
- Remove OptimizeForSize global. Use function attribute optsize. · 1b76f2c4
  Devang Patel authored Oct 01, 2008
```
llvm-svn: 56937
```
  1b76f2c4
Sep 23, 2008
- Instead of setPreservesAll, just mark them preseving machine loop info and machine dominators. · 962c2cf1
  Evan Cheng authored Sep 22, 2008
```
llvm-svn: 56475
```
  962c2cf1
Sep 22, 2008
- Mark several codegen passes as preserving all analysis. · 168f8f39
  Evan Cheng authored Sep 22, 2008
```
llvm-svn: 56469
```
  168f8f39
Sep 04, 2008
- Tidy up several unbeseeming casts from pointer to intptr_t. · a79db30d
  Dan Gohman authored Sep 04, 2008
```
llvm-svn: 55779
```
  a79db30d
Aug 14, 2008
- Use empty() instead of begin() == end(). · 8de6d223
  Dan Gohman authored Aug 14, 2008
```
llvm-svn: 54780
```
  8de6d223
Feb 29, 2008
- Fix PR2112: don't run loop aligner if target doesn't have a TargetLowering object. · 2e26dc80
  Evan Cheng authored Feb 29, 2008
```
llvm-svn: 47755
```
  2e26dc80
- Remove redundant #include. · 88f83994
  Evan Cheng authored Feb 29, 2008
```
llvm-svn: 47748
```
  88f83994
- Added option -align-loops=<true/false> to disable loop aligner pass. · 95a7be47
  Evan Cheng authored Feb 28, 2008
```
llvm-svn: 47736
```
  95a7be47
Feb 28, 2008
- Add a quick and dirty "loop aligner pass". x86 uses it to align its loops to 16-byte boundaries. · c799065c
  Evan Cheng authored Feb 28, 2008
```
llvm-svn: 47703
```
  c799065c