This pass:

1. Splits TargetMachine into TargetMachine (generic targets, can be implemented
any way, like the CBE) and LLVMTargetMachine (subclass of TM that is used by
things using libcodegen and other support).
2. Instead of having each target fully populate the passmgr for file or JIT
   output, move all this to common code, and give targets hooks they can
   implement.
3. Commonalize the target population stuff between file emission and JIT
   emission.
4. All (native code) codegen stuff now happens in a FunctionPassManager, which
   paves the way for "fast -O0" stuff in the CFE later, and now LLC could
   lazily stream .bc files from disk to use less memory.
5. There are now many fewer #includes and the targets don't depend on the
   scalar xforms or libanalysis anymore (but codegen does).
6. Changing common code generator pass ordering stuff no longer requires
   touching all targets.
7. The JIT now has the option of "-fast" codegen or normal optimized codegen,
   which is now orthogonal to the fact that JIT'ing is being done.

llvm-svn: 30081

llvm-svn: 30080

llvm-svn: 30070

Suppose the TokenFactor can reach the Op:

       [Load chain]
           ^
           |
         [Load]
         ^    ^
         |    |
        /      \-
       /         |
      /          [Op]
     /          ^ ^
     |        ..  |
     |       /    |
   [TokenFactor]  |
       ^          |
       |          |
        \        /
         \      /
         [Store]

If we move the Load below the TokenFactor, we would have created a cycle in
the DAG.

llvm-svn: 30040

llvm-svn: 29965

llvm-svn: 29962

or vector result. X86 does not have load/mod/store variants of those
instructions.

llvm-svn: 29957

- Also disable isel load folding if -fast.

llvm-svn: 29956

llvm-svn: 29952

llvm-svn: 29946

Add an optional pass to preprocess the DAG before x86 isel to allow selecting more load/mod/store instructions.

llvm-svn: 29943

llvm-svn: 29911

SDOperand arguments. Use the variants which take an array and number instead.

llvm-svn: 29907

llvm-svn: 29901

llvm-svn: 29898

llvm-svn: 29894

llvm-svn: 29891

does emit linkable .o files in very simple cases.

llvm-svn: 29850

llvm-svn: 29756

llvm-svn: 29752

llvm-svn: 29751

llvm-svn: 29750

llvm-svn: 29747

llvm-svn: 29746

llvm-svn: 29741

llvm-svn: 29726

llvm-svn: 29722

the number of relocations in object files, shrinkifying them.

llvm-svn: 29650

llvm-svn: 29627

llvm-svn: 29614

llvm-svn: 29604

llvm-svn: 29603

llvm-svn: 29601

in the start of an array and a count of operands where applicable.  In many
cases, the number of operands is known, so this static array can be allocated
on the stack, avoiding the heap.  In many other cases, a SmallVector can be
used, which has the same benefit in the common cases.

I updated a lot of code calling getNode that takes a vector, but ran out of
time.  The rest of the code should be updated, and these methods should be
removed.

We should also do the same thing to eliminate the methods that take a
vector of MVT::ValueTypes.

It would be extra nice to convert the dagiselemitter to avoid creating vectors
for operands when calling getTargetNode.

llvm-svn: 29566

selection is done. That's rather expensive especially in situations where it
isn't really needed.
Move back to a searching the predecessors, but make use of topological order
to trim the search space.

llvm-svn: 29559

llvm-svn: 29549

llvm-svn: 29543

llvm-svn: 29504

llvm-svn: 29480

Looks like libstdc++ implementation does not scale very well. Switch back
to using directly managed arrays.

llvm-svn: 29469