llvm-svn: 123169

llvm-svn: 123168

llvm-svn: 123167

llvm-svn: 123166

IDs when available rather than using a mixture of IDs and textual name
comparisons.

llvm-svn: 123165

rolled std::find.

llvm-svn: 123164

allows an argument pack determines via explicit specification of
function template arguments to be extended by further, deduced
arguments. For example:

template<class ... Types> void f(Types ... values);
void g() { 
  f<int*, float*>(0, 0, 0);   // Types is deduced to the sequence int*, float*, int
}

There are a number of FIXMEs in here that indicate places where we
need to implement + test retained expansions, plus a number of other
places in deduction where we need to correctly cope with the
explicitly-specified arguments when deducing an argument
pack. Furthermore, it appears that the RecursiveASTVisitor needs to be
auditied; it's missing some traversals (especially w.r.t. template
arguments) that cause it not to find unexpanded parameter packs when
it should.

The good news, however, is that the tr1::tuple implementation now
works fully, and the tr1::bind example (both from N2080) is actually
working now. 

llvm-svn: 123163

llvm-svn: 123162

intrinsics element dependencies. Reviewed by Nick.

llvm-svn: 123161

llvm-svn: 123160

llvm-svn: 123159

llvm-svn: 123158

When debugging, if an expression hits a SIGABRT, it the expression ends up
completing and stopping due the the "SIGABRT". Then the next thing that runs
(another expression, or continuing the program) ends up progating the SIGABRT
and causing the parent processes to die.

We should probably think of a different solution where we suppress any signal
that resulted due to an expression, or we modifyin the UnixSignals class to
contain a row for "suppress for expression".

So the settings for SIGABRT are: suppress = true, stop = true, and 
notify = true.

llvm-svn: 123157

are all prefixes.

llvm-svn: 123156

These functions not longer assert when passed 0, but simply return false instead.

No functional change intended.

llvm-svn: 123155

them to FileCheck as well.

llvm-svn: 123154

llvm-svn: 123153

llvm-svn: 123152

llvm-svn: 123151

llvm-svn: 123150

llvm-svn: 123149

llvm-svn: 123148

llvm-svn: 123147

back to life.

llvm-svn: 123146

llvm-svn: 123145

llvm-svn: 123144

llvm-svn: 123143

llvm-svn: 123142

llvm-svn: 123141

Fix the TargetRegisterInfo::NoRegister places where someone preferred
typing 'TargetRegisterInfo::NoRegister' instead of typing '0'.

Note that TableGen is already emitting xx::NoRegister in xxGenRegisterNames.inc.

llvm-svn: 123140

llvm-svn: 123139

NUW AddRec's much more aggressively.  We now get a trip count
for @test2 in nsw.ll

llvm-svn: 123138

The numbering plan is now:

0           NoRegister.
[1;2^30)    Physical registers.
[2^30;2^31) Stack slots.
[2^31;2^32) Virtual registers. (With -1u and -2u used by DenseMapInfo.)

Each segment is filled from the left, so any mistaken interpretation should
quickly cause crashes.

FirstVirtualRegister has been removed. TargetRegisterInfo provides predicates
conversion functions that should be used instead of interpreting register
numbers manually.

It is now legal to pass NoRegister to isPhysicalRegister() and
isVirtualRegister(). The result is false in both cases.

It is quite rare to represent stack slots in this way, so isPhysicalRegister()
and isVirtualRegister() require that isStackSlot() be checked first if it can
possibly return true. This allows a very fast implementation of the common
predicates.

llvm-svn: 123137

llvm-svn: 123136

perform rounding other than truncation in the IR. Common C code for this
turns into really an LLVM intrinsic call that blocks a lot of further
optimizations.

llvm-svn: 123135

llvm-svn: 123134

a + {b,+,stride} into {a+b,+,stride}  (because a is LIV),
then the resultant AddRec is NUW/NSW if the client says it
is.

llvm-svn: 123133

llvm-svn: 123132

void f(int* begin, int* end) { std::fill(begin, end, 0); }

which turns into a != exit expression where one pointer is
strided and (thanks to step #1) known to not overflow, and 
the other is loop invariant.

The observation here is that, though the IV is strided by
4 in this case, that the IV *has* to become equal to the
end value.  It cannot "miss" the end value by stepping over
it, because if it did, the strided IV expression would
eventually wrap around.

Handle this by turning A != B into "A-B != 0" where the A-B
part is known to be NUW.

llvm-svn: 123131

when no virtual registers have been allocated.

It was only used to resize IndexedMaps, so provide an IndexedMap::resize()
method such that

 Map.grow(MRI.getLastVirtReg());

can be replaced with the simpler

 Map.resize(MRI.getNumVirtRegs());

This works correctly when no virtuals are allocated, and it bypasses the to/from
index conversions.

llvm-svn: 123130