llvm-svn: 9009

llvm-svn: 9008

llvm-svn: 9007

are ordered by name, not by slot, so the previous solution wasn't any good.
On a large testcase, this reduces time to parse from 2.17s to 1.58s.

llvm-svn: 9002

llvm-svn: 8998

llvm-svn: 8996

llvm-svn: 8994

tasty 15% speedup on the testcase from Bill.

llvm-svn: 8993

if possible.  This provides a consistent 8.5% speedup.

llvm-svn: 8991

Throw the RawInst class in an anon namespace

llvm-svn: 8990

llvm-svn: 8988

llvm-svn: 8986

in practice though

llvm-svn: 8985

changes:
  * BytecodeReader::getType(...) used to return a null pointer
    on error.  This was only checked about half the time.  Now we convert
    it to throw an exception, and delete the half that checked for error.
    This was checked in before, but psmith crashed and lost the change :(
  * insertValue no longer returns -1 on error, so callers don't need to
    check for it.
  * Substantial rewrite of InstructionReader.cpp, to use more efficient,
    simpler, data structures.  This provides another 5% speedup.  This also
    makes the code much easier to read and understand.

llvm-svn: 8984

simplifies the control flow a bit.  This provides a small (~3%) speedup,
but it's primarily a cleanup exercise.

llvm-svn: 8983

This results in no significant speedup, but does provide simpler code

llvm-svn: 8980

new, simpler, ForwardReferences data structure.  This is just the first
simple replacement, subsequent changes will improve the code more.

This simple change improves the performance of loading a file from HDF5
(contributed by Bill) from 2.36s to 1.93s, a 22% improvement.  This
presumably has to do with the fact that we only create ONE placeholder for
a particular forward referenced values, and also may be because the data
structure is much simpler.

llvm-svn: 8979

llvm-svn: 8978

in the bytecode parser.  Before we tried to shoehorn basic blocks into the
"getValue" code path with other types of values.  For a variety of reasons
this was a bad idea, so this patch separates it out into its own data structure.

This simplifies the code, makes it fit in 80 columns, and is also much faster.
In a testcase provided by Bill, which has lots of PHI nodes, this patch speeds
up bytecode parsing from taking 6.9s to taking 2.32s.  More speedups to
follow later.

llvm-svn: 8977

llvm-svn: 8976

Bill gave me from 8.69s to 6.90s.

llvm-svn: 8971

llvm-svn: 8969

llvm-svn: 8965

to avoid reprocessing PHI nodes needlessly.  This speeds up the big bad PHI
testcase 43%: from 104.9826 to 73.5157s

llvm-svn: 8964

llvm-svn: 8963

of a test that Bill Wendling sent me from 228.5s to 105s.  Obviously there is
more improvement to be had, but this is a nice speedup which should be "felt"
by many programs.

llvm-svn: 8962

and TargetInstrDescriptor::ImplicitUses to always point to a null
terminated array and never be null. So there is no need to check for
pointer validity when iterating over those sets. Code that looked
like:

if (const unsigned* AS = TID.ImplicitDefs) {
  for (int i = 0; AS[i]; ++i) {
    // use AS[i]
  }
}

was changed to:

for (const unsigned* AS = TID.ImplicitDefs; *AS; ++AS) {
  // use *AS
}

llvm-svn: 8960

llvm-svn: 8955

llvm-svn: 8954

llvm-svn: 8952

llvm-svn: 8951

llvm-svn: 8930

logarithmic conditional branch sequences instead of linear sequences.  Thanks Bill!

llvm-svn: 8928

llvm-svn: 8922

Thanks to Brian for fixing this obvious oops

llvm-svn: 8899

llvm-svn: 8898

llvm-svn: 8895

llvm-svn: 8894

of callees between executions.

On eon, in release mode, this changes the inliner from taking 11.5712s
to taking 2.2066s.  In debug mode, it went from taking 14.4148s to
taking 7.0745s.  In release mode, this is a 24.7% speedup of gccas, in
debug mode, it's a total speedup of 11.7%.

This also makes it slightly more aggressive.  This could be because we
are not judging the size of the functions quite as accurately as before.
When we start looking at the performance of the generated code, this can
be investigated further.

llvm-svn: 8893

llvm-svn: 8892