This patch adds a `coverage` target that allows coverage statisitics to be
retrieved for the project. It requires that lcov and gcov is installed and
that the generator is unix makefiles but this can be improved upon in
future releases.

To make it work use the coverage build type:

```
cmake -DCMAKE_BUILD_TYPE=Coverage .
make coverage
```

This is useful to test the library at different standard levels. Currently
doesn't search for C++14 in 'auto' mode. Can enable in the future

Can provide speed improvements

This improves development iterations when working in debug mode as you
don't have to fix up warnings to get the code to compile. Once a feature
is complete you can then run a release build and fix up all the warnings.

This checks the flag on the compiler AND linker which allows it to work
with flags such as -flto and -fsanitize=address

Add ability to use benchmark fixtures

support it.

simplify thread linking logic.

they get the appropriate include directories and link libraries automatically.

Fix typos: rangeY -> range_y()

Remove BENCHMARK_ENABLE_SHARED and prefer BUILD_SHARED_LIBS

Libraries are treated as runtime objects on Windows

When the library is created as a *.dll on Windows it is treated like a
runtime object so we must proivde the destination for the runtime
objects in our install command

Clarify build type warning

Add --benchmark_list_tests option and change filter to match generated name.

MinGW support

This file provides scripting to build the benchmark library in the cloud
on the appveyor build system. It provides a matrix of configurations to
cover as many possibilities as it can. Eventually MSVC can be added to the
matrix to provide coverage of the Visual Studio solutions.

The python script provides a method to get the repository of mingw-builds
gcc compilers and download one of them. This is useful for providing a
matrix of compilations on appveyor.

The versions of compilers are seperated by multiple things:

  - version
  - threading model
  - exception model
  - revision

All four of those things need to be matched if using the libraries built
by MinGW. The script allows you to specify all of those variations. If
a variation isn't defined it picks the most common or latest settings.

For example, if the version isn't specified the latest will be selected
and if the exception model isn't defined then the zero exception model
(seh) will be selected if available.

The children CPU usage doesn't seem to have a equivalent on NT systems
so it just returns zero.

For cross platform and cross compiler portability we use the
standard integer type for a 64-bit integer. MinGW on Windows doesn't
have the definition for `int64`.

We use the SHGetValueA on Windows to retrieve the MHz of the processor
but this requires the shlwapi library. Previous to this patch the
library was linked with a MSVC specific pragma but there is no
guarantee that on Windows we will be using MSVC. Therefore, it is much
compile agnostic to use the standard CMAKE library linking mechanism
to provide the definition of SHGetValueA