Rose: be more precise with CATCHUP instruction

- Fix bugs introduced by recent addition of the boundary program. It's
  not safe to do catchup there.
- Only do catchup once per report set, when necessary.

AlignedAllocator: simplify and fix for MSVC, C++11

- Simplify thanks to minimal allocator requirements in C++11.
- Add required copy constructor.

Rose: use program for boundary reports

Use the program to handle report lists at boundaries, rather than the
previous list-of-reports approach.

Rose: make all NFA callbacks take scratch as ctx

Rose: make HWLM callbacks take scratch as ctx

Rose: remove dead function roseHandleMatch

Rose build: move HWLM build code to own file

To reduce the size of rose_build_bytecode.cpp a little, move the code
that deals with HWLM literal tables into its own new file.

Add hs_expression_ext_info() API function

This is a variant of hs_expression_info() that can also accept extended
parameters.

Rose: use program for all literal matches

Unifies all literal match paths so that the Rose program is used for all
of them. This removes the previous specialised "direct report" and
"multi direct report" paths. Some additional REPORT instruction work was
necessary for this.

Reworked literal construction path at compile time in prep for using
program offsets as literal IDs.

Completely removed the anchored log runtime, which is no longer worth
the extra complexity.

Fixed some DEBUG_OUTPUT format string.

ComponentCondReference: mark ctors explicit

Use using directives to silence hiding warning

Remove CMake tests for pthread barriers

Don't enable -Werror for release builds

Using -Werror is a very good thing during development, but it has the
potential to break the user's build, for example, if they are using a slightly
different compiler combination to one that has been tested previously.

Fix typo

Install pkgconfig file everywhere but Windows

Always init NFAContext::cached_br

Now that it's on stack, this should be initialised. Silences a warning
from valgrind.

Correct asserts

Castle: exclusive analysis for multiple subcastle chunks

Apply clique analysis to subcastle chunks if the number of
subcastles is large and check the status of each chunk
separately at runtime.

Rose: further generalise literal dedupe work

Rose: don't assume roles with >1 lit need dedupe

We only require dedupe for such roles when they have literals that can
arrive simultaneously (i.e. one literal overlaps with the suffix of
another).

Rose: make DR runtime path external report only

Rose: only use direct reports for external reports

Rose: allow DR literals to share vertices

Rose: allow direct reports to be aliased

Rose: assign DRs in allocateFinalLiteralId

Previously, direct reports were allocated earlier; now all final IDs are
assigned in the same place.

Improved test for AVX2 support

Test for xsave and XMM/YMM registers. Use ICC dynamic feature detection
where available.

Make comparison signed (fix warning)

Dump: give abs jump targets in output

Rose program: Improvements to debug/assertions

- Add current pc to debug printf.
- Assert that pc doesn't escape the RoseEngine structure.

Update Rose state layout description

Many of the things in this list no longer existed.

Split CHECK_LEFTFIX into CHECK_{INFIX,PREFIX}

reduceInfixQueue: factor out any_work check

Rename rosePrefixCheckMiracles to roseLeftfix...

Rename reduceQueue to reduceInfixQueue

Use rose_inline rather than really_inline

roseTestLeftfix: unify common "nfa is dead" code

Add CATCH_UP to report_block, not "parent" program

Also ensure that exhaustion check happens after catch up, as catch up
may fire reports (which could exhaust).

limex_runtime.h: scratch header no longer needed

Remove more unused structures from unit tests

The NFA, LBR no longer need scratch or the NFAContext structure stored
outside the NFA stack.

NFA API: Remove unused scratch ptr from struct mq

NFA API: Remove nfaBlockExecReverse scratch arg

Scratch is no longer used by this function's implementations.

NFA: Move NFAContext to stack (from scratch)

Rose: allow block-mode merge of small prefixes

Previously, we disallowed the merging of all Rose prefixes in block mode
where the literal sets are not identical.

This change allows merging if the prefix graphs to be merged are very
small, as a small performance improvement for cases with lots of tiny
prefixes.

This check is deliberately conservative: graphs must have some common
vertices, and the result of the merge must not give up any
accelerability.

NFA merging: permit different reports

For cases where the edges from start are not to a mix of accept and
acceptEod, report sets can be combined.

Dump: don't call dumpNfaNotes for SOM reverse NFAs

These NFAs have no queue index.

SET_GROUPS instr: don't generate more than one

dedupeCatchup: only call when necessary at runtime

DEDUPE instr: generate only when necessary

Rose: clean up use of scratch, RoseContext

Rose: pack global state bits into one u8

Eliminate the RoseRuntimeState structure in favour of a single status
byte that is stored in scratch and copied to/from stream state.

Rose: remove alignment req for anchored DFA state

Rose: move more report handling work into program

Move report preconditions (bounds, exhaustion, etc) into program
instructions and use a more direct path to the user match callback than
the adaptor functions.

Report handling has been moved to new file src/report.h. Reporting from
EOD now uses the same instructions as normal report handling, rather
than its own.

Jump target tracking in rose_build_bytecode.cpp has been cleaned up.

ng_filter: Fix bug introduced in 98eff64

If the max width is modified for a region, use the modified version when
checking to see if a self-loop must be added on the last vertex.

RoseRuntimeState no longer needs to be packed

This structure only contains u8 values now. In the future we may wish to
eliminate it entirely and store the few bits we need more directly.

Docs for Rose callback types

Make Rose callback types explicitly take scratch

Remove RoseContext::userCtx

All Rose callbacks receive scratch as their context.

Move cyclic path redundancy into reduce loop

Sometimes cyclic path redundancy can uncover further reduction work that
can be done by the other passes in the reduce loop.

roseEodRunMatcher: correct early return value

nfaCheckFinalState: define return value

Make nfaCheckFinalState return MO_HALT_MATCHING when the user instructs
us (via the callback return value) to halt matching. In the caller,
check this value and stop matching if told.

Don't look for accel friends for multibyte acceleration

scratch: correctly align fatbit arrays

This fixes an assertion failure on 32-bit targets.

Use fatbit for anch log, delay slots in scratch

Since these structures are in scratch, they do not have to be as small
as possible and we can use fatbit instead of multibit to improve
performance.

rose_build_anchored: take ref, not pointer

Account for multi-dfa case with ANCHORED_DELAY

Specifically, we must set build_context::floatingMinLiteralMatchOffset
to 1 when thew anchored table contains multiple DFAs, as they can
produce unordered matches.

This check was already been done, but too late to affect the generation
of ANCHORED_DELAY instructions.

Use correct type for anchored matcher build

Fix release build (unused var)

Remove dupe engine, state ptrs from RoseContext

Remove the RoseEngine and stream state pointers frose RoseContext, as
they are also present in core_info.

Unify stream state handing in Rose to always use a char * (we were often
a u8 * for no particularly good reason) and tidy up.

Coverity: Restore output stream format

Rose: Move all literal operations into program

Replace the RoseLiteral structure with more program instructions; now,
instead of each literal ID leading to a RoseLiteral, it simply has a
program to run (and a delay rebuild program).

This commit also makes some other improvements:

 * CHECK_STATE instruction, for use instead of a sparse iterator over a
   single element.
 * Elide some checks (CHECK_LIT_EARLY, ANCHORED_DELAY, etc) when not
   needed.
 * Flatten PUSH_DELAYED behaviour to one instruction per delayed
   literal, rather than the mask/index-list approach used before.
 * Simple program cache at compile time for deduplication.

squashing: prevent generation of pairs of squash states

alignof() should operate on a type-id

Delete unused build_context::depths

Remove use of depth from Rose entirely

Don't use depth for in-flight check

Remove CHECK_DEPTH instruction

Remove "dot" entries from leftfix lookarounds

Note that we have to be careful to leave the first lookaround entry in
place, if it's a dot. This should eventually be done with a program
instruction.

ComponentRepeat: remove firsts_cache, precalc code

Firsts are easy to compute in ComponentRepeat::first() now.

ComponentRepeat: wire X{0,N} and (X?){N} the same

ComponentRepeat: wire R{0,N} as (R{1,N})?

Change the way that we wire up the edges in a bounded repeat to avoid
large fan-out from predecessors.

ng_prefilter: turn large max bound into inf

During prefilter region replacement, turn regions with very large max
bounds into repeats with inf max bound. This improves compile time and
the likelihood that we will actually be able to build an implementation
for such patterns.

Multibyte matcher unit-tests

Bitmatcher unit-tests

Multibyte acceleration compile side

Multibyte truffle runtime

Multibyte shufti runtime

Multibyte vermicelli runtime

Adding bitmatchers

Adding AVX2 version of truffle

scratch: remove sparse iter state (now unused)

roseRunProgram: iter state on stack

roseCatchUpLeftfixes: iter state on stack

roseBlockHasEodWork: iter state on stack

roseFlushLastByteHistory: iter state on stack

roseCheckNfaEod: use sparse iterator for EOD

Rather than checking all active outfix/suffix engines, use a sparse
iterator to check only those engines that accept at EOD.

runtime: hoist broken check in streaming mode

Build the tools dir only if the cmake file exists

writeEodProgram: avoid make_move_iterator warning

Avoid an ambiguity between std:: and boost::make_move_iterator on builds
against libc++.

rose: Extend program to handle literals, iterators

- cleanups
- add sparse iter instructions
- merge "root" and "sparse iter" programs together
- move program execution to new file program_runtime.h
- simplify EOD execution