llvm-svn: 12260

instructions.

llvm-svn: 12258

by trying to get the compiler to generate an undefined reference for it
and related functions which live in libc_nonshared.a on Linux.

Linkers... sigh.

llvm-svn: 12256

llvm-svn: 12255

llvm-svn: 12254

llvm-svn: 12253

llvm-svn: 12252

llvm-svn: 12251

AllocInfo.Instruction becoming an int.

llvm-svn: 12247

#-1. Other minor changes to deal with AllocInfo.Instruction becoming an int.

llvm-svn: 12246

(Instruction #-1's operands = argument list).

llvm-svn: 12245

from using basic block counts.

llvm-svn: 12242

llvm-svn: 12240

llvm-svn: 12236

using an edge profile to produce block counts gives the exact same numbers
as using a block count directly.

llvm-svn: 12232

llvm-svn: 12231

translation of edge counts into block/function counts when possible.

llvm-svn: 12229

llvm-svn: 12225

llvm-svn: 12224

llvm-svn: 12221

I introduced last night.  Note to self: test the *correct* tree...

llvm-svn: 12220

llvm-svn: 12218

This is one small step towards the complete obliteration of
ConstantPointerRef's entirely!! Woot!

llvm-svn: 12216

llvm-svn: 12214

llvm-svn: 12212

llvm-svn: 12208

llvm-svn: 12207

testcase like this:

int %test(int* %P, int %A) {
        %Pv = load int* %P
        %B = add int %A, %Pv
        ret int %B
}

We now generate:
test:
        mov %ECX, DWORD PTR [%ESP + 4]
        mov %EAX, DWORD PTR [%ESP + 8]
        add %EAX, DWORD PTR [%ECX]
        ret

Instead of:
test:
        mov %EAX, DWORD PTR [%ESP + 4]
        mov %ECX, DWORD PTR [%ESP + 8]
        mov %EAX, DWORD PTR [%EAX]
        add %EAX, %ECX
        ret

... saving one instruction, and often a register.  Note that there are a lot
of other instructions that could use this, but they aren't handled.  I'm not
really interested in adding them, but mul/div and all of the FP instructions
could be supported as well if someone wanted to add them.

llvm-svn: 12204

llvm-svn: 12203

This allows pointers to aggregate objects, whose elements are only read, to
be promoted and passed in by element instead of by reference.  This can
enable a LOT of subsequent optimizations in the caller function.

It's worth pointing out that this stuff happens a LOT of C++ programs, because
objects in templates are generally passed around by reference.  When these
templates are instantiated on small aggregate or scalar types, however, it is
more efficient to pass them in by value than by reference.

This transformation triggers most on C++ codes (e.g. 334 times on eon), but
does happen on C codes as well.  For example, on mesa it triggers 72 times,
and on gcc it triggers 35 times.  this is amazingly good considering that
we are using 'basicaa' so far.

llvm-svn: 12202

llvm-svn: 12200

llvm-svn: 12198

a zero value is the most likely way to cause further simplification, so we do it.

llvm-svn: 12197

llvm-svn: 12195

variables.

llvm-svn: 12193

llvm-svn: 12190

llvm-svn: 12189

llvm-svn: 12188

Emit RETL instruction to return instead of funny JMPL.
Fix indentation.

llvm-svn: 12186

Add RET, RETL.  Rename SAVE, RESTORE & JMPL for consistency.

llvm-svn: 12185