llvm-svn: 11868

other clients.  The problem is that the nullVal member was left to the default
constructor to initialize, which for int's does nothing (ie, leaves it unspecified).

To get a zero value, we must use T().  It's C++ wonderful? :)

llvm-svn: 11867

Remove .micro references as those files no longer exist and add some more recent Makefile additions to the list

llvm-svn: 11866

llvm-svn: 11865

llvm-svn: 11864

not have any globals.

llvm-svn: 11863

llvm-svn: 11862

removes some cruft from 255.vortex, cleaning up after DAE and IPCP, which
do horrible, beautiful, things to vortex.

llvm-svn: 11861

bugs.  Thanks Brian!

llvm-svn: 11859

llvm-svn: 11858

llvm-svn: 11857

them when all the problem areas are fixed.

llvm-svn: 11855

llvm-svn: 11854

llvm-svn: 11853

 1. Functions do not make things incomplete, only variables
 2. Constant global variables no longer need to be marked incomplete, because
    we are guaranteed that the initializer for the global will be in the
    graph we are hacking on now.  This makes resolution of indirect calls happen
    a lot more in the bu pass, supports things like vtables and the C counterparts
    (giant constant arrays of function pointers), etc...

Testcase here: test/Regression/Analysis/DSGraph/constant_globals.ll

llvm-svn: 11852

llvm-svn: 11851

local graph that uses the global.

llvm-svn: 11850

MRegisterInfo::is{Physical,Virtual}Register.

llvm-svn: 11849

Make the incompleteness marker faster by looping directly over the globals
instead of over the scalars to find the globals

Fix a bug where we didn't mark a global incomplete if it didn't have any
outgoing edges.  This wouldn't break any current clients but is still wrong.

llvm-svn: 11848

llvm-svn: 11847

llvm-svn: 11846

pair, and look up varargs in the execution stack every time, instead of
just pushing iterators (which can be invalidated during callFunction())
around.  (union GenericValue now has a "pair of uints" member, to support
this mechanism.) Fixes Bug 234.

llvm-svn: 11845

llvm-svn: 11844

llvm-svn: 11843

passed the special 'register' 0.

llvm-svn: 11842

llvm-svn: 11841

to objects.

llvm-svn: 11840

llvm-svn: 11839

llvm-svn: 11838

llvm-svn: 11837

assume that if they don't intend to write to a global variable, that they
would mark it as constant.  However, there are people that don't understand
that the compiler can do nice things for them if they give it the information
it needs.

This pass looks for blatently obvious globals that are only ever read from.
Though it uses a trivially simple "alias analysis" of sorts, it is still able
to do amazing things to important benchmarks.  253.perlbmk, for example,
contains several ***GIANT*** function pointer tables that are not marked
constant and should be.  Marking them constant allows the optimizer to turn
a whole bunch of indirect calls into direct calls.  Note that only a link-time
optimizer can do this transformation, but perlbmk does have several strings
and other minor globals that can be marked constant by this pass when run
from GCCAS.

176.gcc has a ton of strings and large tables that are marked constant, both
at compile time (38 of them) and at link time (48 more).  Other benchmarks
give similar results, though it seems like big ones have disproportionally
more than small ones.

This pass is extremely quick and does good things.  I'm going to enable it
in gccas & gccld.  Not bad for 50 SLOC.

llvm-svn: 11836

llvm-svn: 11835

llvm-svn: 11834

llvm-svn: 11833

llvm-svn: 11832

llvm-svn: 11831

llvm-svn: 11830

where there did not used to be any before

llvm-svn: 11829

llvm-svn: 11828

llvm-svn: 11827