Use syntax tables for SPIR-V 1.0 Rev3

- The SPIR-V spec generator has changed how it represents optional
  operands.  Now it tracks a separate boolean flag indicating optionality.
  However, SPIRV-Tools still wants to represent both operand class
  and optionality in the same enums space (SPV_OPERAND_TYPE_*).
  So there's extra work in the patch.

- In the spec generator, OperandImage is now OperandImageOperands.
  This affects enum translation in opcode.cpp.

- In the spec generator, image operands are explicitly followed by
  Id, and VariableIds.  However, SPIRV-Tools uses the bits set
  in the image operand bitmask to control the number and meaning
  of the Ids that follow.  So in writing the opcode.inc syntax
  table, drop all operands after OperandImageOperands.

- Some enums are now more explicitly represented in the generated
  opcode.inc:
    - AccessQualifier (e.g. on OpTypeImage), in both required and
      optional flavours.
    - MemoryAccess (e.g. on loads and stores)

- Add SPV_OPERAND_TYPE_OPTIONAL_ACCESS_QUALIFIER

- Add tests for the optional AccessQualifier operand on OpTypeImage.

- Update the AccessQualifier test for OpTypeImage so it's a round
  trip test through the disassembler as well.

Update capabilities for 1.0 Rev3

Don't promise particular values when float parsing fails.

This should address problems on Windows:
https://github.com/KhronosGroup/SPIRV-Tools/issues/104

Configure gmock locally only if not already configured.

Allows an enclosing project to have already configured gmock, even
if the developer has placed the googletest sources under this
project's external/googletest directory.

Describe how to enable the tests in the two essential scenarios:
where SPIR-V Tools is standalone, or where SPIR-V Tools is configured
as a part of a larger project.

Use SPIR-V headers for 1.0 Rev3

Refresh from the SPIR-V registry.

Parse overflow for fp16  like for 32- and 64-bit

In that case, set the stream fail bit, and set the maximum normal
value or lowest normal value, depending on the sign of the original
value.

Float literal parsing fixes

- For 32- and 64-bit floats, overflow is a parse error

  This works around a difference between Xcode's istringstream
  and other platforms.  Xcode's runtime library will happlily
  "round up" overflow values to infinity.  We want to make it fail.

- When parsing a float fails due to bad syntax, follow C++11
  behaviour for operator>> and set the value to zero.

- When parsing a 32-bit or 64-bit float overflows, follow C++11
  behaviour for operator>> and set the value to the nearest
  normal value: either max or lowest finite value for the type.

- Add FloatProxy<T>::max() and ::lowest()

- Make 16-bit overflow behaviour more consistent: we always get a
  16-bit infinity of the right sign, whether the original string
  is a normal value for 32-bit or an overflow value for 32-bit.
  That matches our earlier intent.
  Added TODO's to make 16-bit overflow always an error, just like
  for 32-bit and 64-bit.

- Simplify normal parsing of Float16 values by delegating to
  normal parsing of 32-bit floats.

Reject float literals with two leading signs

E.g. --1 should be rejected.

More parsing tests for literals with leading minus

Also checks some hex literal cases.

This addresses part of
https://github.com/KhronosGroup/SPIRV-Tools/issues/45
by removing the parseNumber case for "-0" on unsigned
integers.  We don't care about that platform difference
at the level of std::istringstream, since we reject it
at a higher parsing level.

Make IsTypeNullable a transitive check.

Eliminate parameter-order check from ID-validation.

Allow Op[No]Line between OpFunctionParameters.

Also ensure we don't get thrown off by too many parameters.

Enable ctest.

Validation of mask operand capabilities is more data driven

Use spvOperandIsConcreteMask to determine if an operand is
a bitmask.  Check its individual bits in a generic way.

Add spvOperandIsConcreteMask

Use AssemblyGrammar for capability validation.

Also:
- ForEach() for spv_capability_mask_t.
- Add capability min/max constants.
- Move max definition from validate_types.cpp to spirv_definition.h.

Forbid Generic variables.

Fix validator mem overflow when tracking capabilities

Fix in-function storage class validation.

Move tests into a fixture that properly turns on the relevant passes.

Initialize vector<string>s on first use, not statically.

Fix validation of return value.

Remove spvOpcodeIsObject().

Also
- Add type_id to spv_id_info_t.
- Use spv_id_info_t::type_id instead of words[1].
  Triggered some asserts on tests, where the code incorrectly assumed
  words[1] had a type.  Remove the asserts and handle gracefully.
- Add tests for OpStore of a label, a void, and a function.

Initial capability implementation and unit tests

* Register capabilility and checks
* Add validate storage class capabilities checks and tests
* Instruction pass refactor
  - More generic form of capability checking by checking operands
    instead of instructions
* Execution Model capabilities checks
* Decorate BuiltIn capability checks
* Addressing Model capability checks
* Memory Model capability checks
* Execution Mode capability checks
* Dim capability checks
* SamplerAddressingMode capability checks

Qualify CMake function names with "spvtools" to avoid conflictions.

If a third-party project defines a CMake function with the same
name, by importing that project's CMake configuration, we may end
up overwriting our own copy. Qualify all defined functions to
reduce that probability.

Fix spvOpcodeIsScalarType() to include Boolean.

Remove redundant validations of OpConstant and OpConstantComposite.
Binary parser already performs these checks, so the validations can
never be triggered.

Enable bad-constant tests.

Don't fail validation in unimplemented cases.

Fix OpLoad pointee type validation.

Add disassembler option to show byte offset

The option is disabled by default.

The offset is printed in hex, as a comment after each instruction.

Track uses and defs during parsing.

Replace two other, imperfect mechanisms for use-def tracking.

Use ValidationState_t::entry_points to track entry points.

Concentrate undefined-ID diagnostics in a single place.

Move validate_types.h content into validate.h due to increased
inter-dependency.

Track uses of all IDs: TYPE_ID, SCOPE_ID, ...

Also update some blurbs.

Fix entry-point accumulation and move it outside ProcessIds().

Remove validate_types.h from CMakeLists.txt.

Blurb for spvIsIdType.

Remove redundant diagnostics for undefined IDs.

Join "can not" and reformat.

Since g++-4.9 has an ICE occasionally in travis add a retry.

Try to re-run the build with ninja -j 1 if the build fails,
this should reduce the number of build failures we see.

Fix missing OpNoLine layout checks

Disable warnings C4503 on MSVC for test code

C4503 is "decorated name length exceeded", triggered
by some heavily templated types.

Validation refactor

* Organize passes into seperate files
* Remove module layout logic from Cfg pass
* Remove module layout logic from Functions class
* Refactor ModuleLayoutPass for readability
* Adapt consistent naming of layout sections (Stage/Section -> Section)

Add configuration for Travis CI.

Add missing branch instructions in SSA tests

Remove static vector from GetModuleOrder

Fixed warning in VS2013 build.

Signed/Unsigned mismatch in progressToNextLayoutStageOrder().

Fix, that spirv-tools did not build, as two casts are not present.

Fix build by renaming ValidationState_t constructor argument.

The `diag` argument shadows the `diag` method, so the strict build fails.

Function and block layout checks. very basic CFG.

This adds function and block layout checks to the validator. Very
basic CFG code has been added to make sure labels and branches
are correctly ordered.

Also:
* MemoryModel and Variable instruction checks/tests
* Use spvCheckReturn instead of CHECK_RESULT
* Fix invalid SSA tests
* Created libspirv::spvResultToString in diagnostic.h
* Documented various functions and classes
* Fixed error messages
* Fixed using declaration for FunctionDecl enum class

Fixed use-after-free in isStartOfNewInst() tests.

Minor fixes to remove warnings in VS2013.

Also fixes VS2015 build due to missing #include <iterator>

spvDiagnosticDestroy is safe to call on nullptr

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/62

Fix endian-ness conversion in the binary parser.

When we were swapping endian-ness in the binary parser, we would
write outside of the bounds of our vector.

Made compilation with gcc and clang more strict.

Added additional compilation flags to gcc and clang builds.
Adds -Wall -Wextra -Wno-long-long -Wshadow -Wundef -Wconversion
-WNo-sign-conversion and -Wno-missing-field-initializers
where appropriate.

Does not add -Wundef to tests, because GTEST tests undefined
macros all over the place.

Support 16-bit float in assembler and disassembler

This adds half-precision constants to spirv-tools.
16-bit floats are always disassembled into hex-float format,
but can be assembled from floating point or hex-float inputs.

Extend copyright to 2016.

Undefine a macro after use.

Fix shadowing warnings reported by GCC

Fix conversion warnings reported by GCC.

Explicitly convert to narrower type.

Fixes a strict Clang warning.

Avoid variable shadowing

Avoid warning for implicit conversion of char array to bool.

Clang complains about assert("unhandled") but not
assert(false && "unhandled").

Fix var shadowing and width mismatches in hex_float.h

Avoid parameter shadowing in source/diagnostic.h

Change the offending class to more closely follow Google C++ style:
- Member names have a trailing underscore.
- Use an accessor method for the stream_ member.

Fix list of opcodes allowed for OpSpecConstantOp

Was missing BitcastXor, GenericCastToPtr.
Remove duplicate of SLessThanEqual

operator<< on FloatProxy preserves float and fill

Fixes formatting of disassembler output after printing
a hex float, e.g. for a NaN or subnormal.

Fix parser assert failure for a bad OpSwitch

Emit a diagnostic if the OpSwitch selector refers to an ID that
is valid but has no type.

Discovered by afl-fuzz.

Avoid relative path in #include

Adds CMAKE_CURRENT_SOURCE_DIR to the include path for UnitSPIRV

Rename endian.h to spirv_endian.h

If we later add a source/ as an -I include directory,
then avoid confusing other headers that want to include the
standard "endian.h" from /usr/include.

Also rename source/endian.cpp to source/spirv_endian.cpp

Add spirv.py from the SPIR-V 1.0.2 registry

Initial logical layout validation

* Validates module level instructions for logical layout
  conformance
* Does not validate:
  1. Function logical layout
  2. Minor cases with OpVariable
  3. Missing MemoryModel instruction in module
  4. Order of function definition and function declaration
* 782 unit tests for logical layout

Addressed feedback

Refactor validation types into another file

Fix tests which rely on OpName;Use EXPECT_THAT

All OpName calls should appear before annotation and type
declarations.

Fix warnings with Apple clang++

* Unused private member
* Overflow error when subtracting num_fraction_bits for HF16 and HF

Fix setting of off-by-default cmake options

An enclosing CMake project should be able to set the
off-by-default CMake options in SPIRV-Tools by just doing:
  set(SPIRV_SKIP_EXECUTABLES ON)
instead of
  set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "" FORCE)

Also, fix the SPIRV_WARN_EVERYTHING so it understands which options
to send to Clang vs. GCC.

Note: With SPIRV_WARN_EVERYTHING enabled, the code doesn't
compil with either Clang or GCC.

Basic SSA Validation

Most uses of an ID must occur after the definition
of the ID.  Forward references are allowed for
things like OpName, OpDecorate, and various cases
of control-flow instructions such as OpBranch, OpPhi,
and OpFunctionCall.

TODO: Use CFG analysis for SSA checks.  In particular,
an ID defined inside a function body is only usable inside
that function body.  Also, use dominator info to catch
some failing cases.

Also:
* Validator test cases use (standard) assignment form.
* Update style to more closely follow the Google C++ style guide
* Remove color-diagnostics flag.
  This is enabled by default on terminals with color. Prints
  hidden ASCII for terminals that can't handle color(Emacs)
* Pass functors to SSAPass to check if the
  operand can be forward referenced based on its index value
* Return SPV_ERROR_INVALID_ID for ID related errors
  spvBinaryParse returned SPV_ERROR_INVALID_BINARY for all types of
  errors. Since spvBinaryParse does some ID validation, this was
  returning inappropriate error codes for some tests.
* Common fixture for validation tests.
  It only runs certian validation passes.
* Add a SPV_VALIDATE_SSA_BIT for testing purposes
* Fixtures now return error codes
* Add OpName support in diag message and unit tests
* Binary parsing can fail with invalid ID or invalid binary error code

Tests include:
* OpDecorate
* OpName
* OpMemberName
* OpBranchConditional
* OpSelectionMerge
* OpMemberDecorate
* OpGroupDecorate
* OpDeviceEnqueue
* Enable several tests failing in ID validation.

Added Float16, and HexFloat conversions

Fix namespace on PrintTo

PrintTo on WordVector should preserve the fill char

Stated word count is several more than expected

These are extra binary parsing cases.

Use static_cast instead of constructor for uint32_t

OpDecorate should not accept any number of literal operands.

This is a grammar fix.  The Decoration operand of OpDecorate (and
OpMemberDecorate) determines the remaining operands.  Don't just
allow any number of literal numbers as operands.

(The OperandVariableLiterals operand class as the last member
of the OpDecorate and OpMemberDecorate entries in in opcode.inc is
an artifact of how the spec generates the opcode descriptions. It's
not suitable for parsing those instructions.)

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/34

binary parse test: extra words after string literal

Covers the case where the string literal is the
last operand.

TODO: Case where one more operand is expected after
the string literal.  Occurs only for the LinkageAttributes
decoration.  To test that, we need to update the grammar
as well.

Don't add -frtti for tests. Use newer googletest.

Using -frtti caused link failures when both of the following are
in effect:
-DDISABLE_EXCEPTIONS=ON
-DDISABLE_RTTI=ON

The correct fix is to use tip-of-tree googletest.
Specifically, we need a version of googletest with the fix in
https://github.com/google/googletest/pull/612
In particular, it must be later than googletest 1.7.0.

Add -frtti for tests that use mocking

The tests now use mocked methods.  This requires runtime type
information for those test classes.
https://github.com/google/googletest/issues/610

This has been fixed recently upstream in googletest.  Until we pick
up that fix, add -frtti for the the test executable only.

Merge PR #32.

Simplify binary parser tests using GoogleMock.

Mention that ParsedInstruction owns its components.

Also close a parenthesis in ParsedInstruction printout.

spvBinaryParse: fix overruns, handle image format

Add unit tests for all diagnostics issued by spvBinaryParse.

Handle image format operands in the binary parser and the
disassembler.

Document that the callback function pointers can be null,
in which case they are ignored.

Detect exhaustion of input when parsing an operand,
to avoid buffer overruns on some invalid input cases.

Fix the description strings for some operand types.
Make the diagnostic messages for those operand types
consistent between the assembler and binary parser.

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/29

Clarify the non-SPV_SUCCESS case parser callbacks.

When a callback returns something other than SPV_SUCCESS,
then no futher callbacks are issued (parsing terminates early),
and no additional diagnostics are emitted.

The unit tests already check this behaviour.

Several unit tests for spvBinaryParse

Add a non-zero spv_result_t value SPV_REQUESTED_TERMINATION
which should be used to signal an ok result, but signals
early termination for a process, such as binary parsing.

Tests include:
 - correct contents sent to header and instruction callbacks
 - non-zero status from a callback should terminate parsing,
   but the parser should not generate its own diagnostic.

TODO: Check diagnostics generated by the parser itself.

Aliasing through a union member is valid.

Take back my previous TODO.

Fix compilation of an assert.

The asserts check the length of the endian-converted words
vector with the reported number of words in the instruction.

spv_parsed_instruction_t cleanup

Add members:
 - words: a pointer to an array of words in the instruction,
   in host native endianness.
 - num_words: sizes the words member

Remove member:
 - offset

This simplifies clients of spvBinaryParse, because they don't
have to handle endianness translation.

Also, it makes the binary parse API more composable, allowing
for easy chaining of binary parse clients.  A binary parse client
is handed the array of words directly instead of having to reference
some external array of all the words in the SPIR-V binary.  It also
allows a binary parse client to mutate the instruction stream before
handing off to a downstream consumer.

TODO(dneto): Still need to write the unit tests for spvBinaryParse

Fixes: https://github.com/KhronosGroup/SPIRV-Tools/issues/1

Merge pull request #23.

Fixing some C++ conversion errors.
* Implicit conversion from int to bool.
* Implicit conversion from size_t to uint32_t.
* Implicit conversion from char* to uint8_t.

Adding no-op color operators so unhandled platforms can still link.

Put DiagnosticStream and clr exports in libspirv namespace

Each exported functions either has an "spv" prefix, or is inthe libspirv
namespace.

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/18

Fix paths for binaries to match changes in CMake configuration.

Use test fixture for a test.

Removed executable flag from HexFloat.cpp.

Updated spirv.h header. Fixes SPV_VERSION macro

The SPV_VERSION macro value was updated to be 0x10000.
Previously it was missing the "0x" prefix, which caused
confusion.

The value of the const unsigned int SpvVersion has always
been 0x00010000.  That's what should appear as the version
word in the SPIR-V header.

The SPV_VERSION symbol is to be used in preprocessor directives.

Turned warnings-as-errors on by default.

Fixed a few warnings that appear in builds on VS2013 and VS2015.

Clean up CMake configuration and address compiler warnings.

- Removed dead configuration in CMakeLists.txt.
- Used target_compile_options() instead of CMAKE_{C|CXX}_FLAGS.
- Turned on warnings on tests.
- Fixed various warnings for comparing signed with unsigned values.
- Removed dead code exposed by compiler warnings.

Remove old names for enums: memory semantics, scope ID

Bottom byte of version header word should be 0

The assembler should always make it 0.
The disassembler should ignore it.

Remove the macro support for supplying a value for it.

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/6

CMake: Respect user-defined install path

Object files should depend on spirv.h and friends

Don't use SYSTEM attribute on include_directories directive
for the SPIR-V standard header files.  When you do, object files
are not considered dependent on those headers.

Checked by looking at the dependency file source/disassemble.cpp.o.d,
and by trying to compile after a trivial edit to spirv.h

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/7

Also, use "" inclusion instead of <> inclusion for standard SPIR-V
headers.

Fix test: version number has changed.

Update external headers.

Now use the headers published at
https://www.khronos.org/registry/spir-v/api/1.0/.

Use Google comment style and fix typos.

Fix grammar: "The SPIR-V Tools project provides"