Change to use enum instead of enum class for MessageLevel.

This allows us to create C interface with MessageLevel later.

Add a C++ interface to the optimization functionalities.

Allow changing MessageConsumer in Pass & PassManager.

Default-constructed Pass/PassManager will have a MessageConsumer
which ignores all messages. SetMessageConsumer() should be called
to supply a meaningful MessageConsumer.

Change BuildModule() to accept pointer-size pair for binary.

Change interface of Pass::Process() to return possible failures.

Provide friendly names for shader ballot BuiltIns

Update validate interface to accept binary pointers

Set the default source name as "input".

Start v2016.6-dev

Finalize v2016.5

Add basic support for SPV_KHR_shader_ballot

Requires use of SPIRV-Headers that has support
for SPV_KHR_shader_ballot.

Adds assembler, disassembler, binary parser support.

Adds general support for allowing an operand to be
only enabled by a set of extensions.

TODO: Validator support for extension checking.

Prepare the C++ interface for publication.

* Use PIMPL idiom in the C++ interface.
* Clean up interface for assembling and disassembling.
* Add validation into C++ interface.
* Add more tests for the C++ interface.

Move functions for building modules outside of the C++ interface.

Let SPIRV_ASSERT() exit the program if the assertion fails.

Add MessageConsumer to PassManager, Pass, and analysis interfaces.

Also convert some uses of assert() in optimization code to use
SPIRV_ASSERT(), SPIRV_UNIMPLEMENTED(), or SPIRV_UNREACHABLE()
accordingly.

Add utility macros for logging messages.

Add the following macros for logging purpose:
* SPIRV_ASSERT
* SPIRV_DEBUG
* SPIRV_UNIMPLEMENTED
* SPIRV_UNREACHABLE

The last two is always turned on, while the first two can only
be turned on in debug build.

Add a callback mechanism for communicating messages to callers.

Every time an event happens in the library that the user should be
aware of, the callback will be invoked.

The existing diagnostic mechanism is hijacked internally by a
callback that creates an diagnostic object each time an event
happens.

Make friendly names for built-in variables.

Handles only OpDecorate

Does not handle:
- decorations on struct members
- decoration via OpGroupDecorate

Update CHANGES to say #414 is fixed

Fix validator: OpUndef can be member of a constant composite

This was enabled in SPIR-V 1.0 Rev 7

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

Clarify: Ok to pass null diagnostic to spvBinaryParse

It's a valid use case: I might mostly trust my binaries and I don't
care to to collect detailed diagnostic feedback.

Fix validator SSA check: Phi can use its own value sometimes

Defer removal of a Phi's result id from the undefined-forward-reference
set until after you've scanned the arguments.  The reordering is only
significant for Phi.

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

Build "spec id->default val str" mapping from string

Add function `ParseDefaultValuesString()` to build the spec id->default
value string mapping required by `SetSpecConstantDefaultValuePass`.

Guard against nullptr in number parsing utilities

ParseNumber(): Returns false if the given string is a nullptr.
ParseAndEncodeXXXX(): Returns kInvalidText and populate error message:
  "The given text is a nullptr", if the givne string is a nullptr.

Set default values for spec const decorated by SpecId

The pass instance is constructed with a map from spec id (uint32_t) to
default values in string format. The default value strings will be
parsed to numbers according to the target spec constant type.

If the Spec Id decoration is found to be applied on multiple different
target ids, that decoration instruction (OpDecorate or OpGroupDecorate)
will be skipped. But other decoration instrucitons may still be
processed.

Update CMake condition for Emacs load/save helper

Make SPIRV_TOOLS_INSTALL_EMACS_HELPERS a CMake option.  Otherwise
I get a variable-defined-but-not-used error.

add spirv-dis/spirv-as support for emacs when loading .spv binaries

Add IsSigned() to opt::Analysis::Integer.

Pull out the number parsing logic

Pull out the number parsing logic from
AssemblyContext::binaryEncodeNumericLiteral() to utilities.

The new utility function: `ParseAndEncodeNumber()` now accepts:
  * number text to parse
  * number type
  * a emit function, which is a function which will be called with each
    parsed uint32 word.
  * a pointer to std::string to be overwritten with error messages.
    (pass nullptr if expect no error message)
and returns:
  * an enum result type to indicate the status

Type/Structs moved to utility:
  * template<typename T> class ClampToZeroIfUnsignedType

New type:
* enum EncodeNumberStatus: success or error code
* NumberType: hold the number type information for the number to be parsed.
 * several helper functions are also added for NumberType.

Functions moved to utility:
  * Helpers:
    * template<typename T> checkRangeAndIfHexThenSignExtend() -> CheckRangeAndIfHex....()
  * Interfaces:
    * template<typename T> parseNumber() -> ParseNumber()
    * binaryEncodeIntegerLiteral() -> ParseAndEncodeIntegerNumber()
    * binaryEncodeFloatingPointLiteral() -> ParseAndEncodeFloatingPointNumber()
    * binaryEncodeNumericLiteral() -> ParseAndEncodeNumber()

Tests added/moved to test/ParseNumber.cpp, including tests for:
* ParseNumber(): This is moved from TextToBinary.cpp to ParseNumber.cpp
* ParseAndEncodeIntegerNumber(): New added
* ParseAndEncodeFloatingPointNumber(): New added
* ParseAndEncodeNumber(): New added

Note that the error messages are kept almost the same as before, but
they may be inappropriate for an utility function. Those will be fixed
in another CL.

Merge diagnostic tests and single them out in a separate binary.

Create separate binaries for validation tests.

Prefix test binaries with `test_`, rename UnitSPIRV, update README.

Travis CI: mark build as finished once a job failed.

Kill the spvCheck macro which is just alias to if-statement.

Update README about the optimization library and tool.

Say contributors have to click through the CLA

Add test for presence of copyrights and license terms

Start v2016.5-dev

Relicense SPIRV-Tools under Apache 2.0

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

Finalize v2016.4

Add check_copyright to check or update copyright.

It will also replace an MIT or Khronos free use license with
the Apache license notice.

Fix Google copyright lines

Kill the spvCheckReturn macro.

Kill diagnostic_helper & the wrapping DIAGNOSTIC macro.

Tests for preserving line debug insts even killing its affecting targets.

Unify constants pass

De-duplicate constants and unifies the uses of constants for a SPIR-V
module. If two constants are defined exactly the same, only one of them
will be kept and all the uses of the removed constant will be redirected
to the kept one.

This pass handles normal constants (defined with
OpConstant{|True|False|Composite}), some spec constants (those defined
with OpSpecConstant{Op|Composite}) and null constants (defined with
OpConstantNull).

There are several cases not handled by this pass:

  1) If there are decorations for the result id of a constant defining
  instruction, that instruction will not be processed. This means the
  instruction won't be used to replace other instructions and other
  instructions won't be used to replace it either.

  2) This pass does not unify null constants (defined with
  OpConstantNull instruction) with their equivalent zero-valued normal
  constants (defined with OpConstant{|False|Composite} with zero as the
  operand values or component values).

Refactor CapabilitySet into templated class EnumSet

Add forwarding so that passes' ctor can have args.

Also removed the default argument value of `skip_nop` for function
`SinglePassRunAndCheck()` and `SinglePassRunAndDisassemble()`. This is
required to support variadic arguments.

Handle capabilities larger than value 63

Use libspirv::CapabilitySet instead of a 64-bit mask.

Remove dead function spvOpcodeRequiresCapability and its tests.

The JSON grammar parser is simplified since it just writes the
list of capabilities as a braced list, and takes advantage of
the CapabilitySet intializer-list constructor.

Add libspirv::CapabilitySet

It's optimized for the common case, where capabilities have value
at most 63.

Get annotation instructions of a given id.

Add AppendNames() interface for AssemblyBuilder

Create a separate header and source file for each pass.

Fold spec constants to normal constants (values fixed)

For the spec constants defined by OpSpecConstantOp and
OpSpecContantComposite, if all of their operands are constants with
determined values (normal constants whose values are fixed), calculate
the correct values of the spec constants and re-define them as normal
constants.

In short, this pass replaces all the spec constants defined by
OpSpecContantOp and OpSpecConstantComposite with normal constants when
possible. So far not all valid operations of OpSpecConstantOp are
supported, we have several constriction here:

1) Only 32-bit integer and boolean (both scalar and vector) are
supported for any arithmetic operations. Integers in other width (like
64-bit) are not supported.
2) OpSConvert, OpFConvert, OpQuantizeToF16, and all the
operations under Kernel capability, are not supported.
3) OpCompositeInsert is not supported.

Note that this pass does not unify normal constants. This means it is
possible to have new generatd constants defining the same values.

Pass manager recomputes Id bound automatically.

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/371
in the sense that the id bound is correct after all the passes
have been run.  But it might be inconsistent between passes.

Create const overloads for begin() and end() in Instruction.

Fix typo in spirv-opt help

Add Module::ComputeIdBound

When IDs change, something should use this utility method
and Module::SetIdBound before writing out the binary.

Add tests for decoration_empty().

Add a method in the types to check whether there is no decoration on a
type.

Test ir::Instruction::GetOperand and GetInOperand

IrLoader gracefully handles incomplete blocks and functions

This lets us write smaller test cases with the IrLoader, avoiding
boilerplate for function begin/end, and basic block begin/end.

Also ForEachInst is more forgiving of cases where a basic block
doesn't have a label, and when a function doesn't have a defining
or end instruction.

Add Instruction begin and end mutable iterators

Refactored the instuction test.

Add Instruction cbegin and cend to access operands

ForEachInst optionally runs on attached debug line insts

Also:
- Add const forms of ForEachInst
- Rewrite Module::ToBinary in terms of ForEachInst
- Add Instruction::ToBinaryWithoutAttachedDebugInsts
- Delete the ToBinary method on Function, BasicBlock, and Instruction
  since it can now be implemented with ForEachInst in a less confusing
  way, e.g. without recursion.
- Preserve debug line instructions on OpFunctionEnd (and store that
  instruction as a unique-pointer, for regularity).

Travis CI: add build configuration for Android NDK with cmake.

Start v2016.4-dev

Finalize v2016.3

Add spirv-lesspipe.sh

Idea suggested by @steve-lunarg in issue 359.

Mere mention of PointSize BuiltIn does not require Shader capability

Fixes https://github.com/KhronosGroup/SPIRV-Tools/issues/365 which
was reopened for this.

Add a home brewed make_unique to ease creating unique_ptrs.

Remove some unused macros and functions.

CHANGES captures fix for issue 365

Relax ClipDistance, CullDistance capability check in all environments

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

Add opt::ir::Module::SetIdBound

Get the number of elements for Vector and Matrix type

Refine the DefUseManager

* Fix the behavior when analyzing an individual instruction:
  * exisiting instruction:
      Clear the original records and re-analyze it as a new instruction.
  * new instruction with exisiting result id:
      Clear the original records of the exisiting result id. This means
      the records of the analyzed result-id-defining instruction will be
      overwritten by the record of the new instruction with the same
      result id.
  * new instruction with new result id or without result id:
      Just update the internal records to incorperate the new
      instruction.
* Add tests for analyzing individual instruction w/o an exisiting module.
* Refactor ClearInst() implementation
* Remove ClearDef() function.
* Fixed a bug in DefUseManager::ReplaceAllUsesWith() that OpName
  instruction may trigger the assertion incorrectly.
* update the blurbs for EraseUseRecordsOfOperandIds()

Get the width from integer and float type

Replace the SetOperand() with SetInOperand() and SetResultType()

Make clear that we are using ptrdiff_t as the iterator difference type.

And ptrdiff_t is a implementation defined signed type. Comparing it
with unsigned number literal causes compiler warnings.

Derive iterator from std::iterator to reap standarad algorithms.

By deriving from std::iterator, iterator_traits will be properly
set up for our custom iterator type, thus we can use algorithms
from STL with our custom iterators.

Make analyses RAII-like and turn disable copy/move constructors.

Avoid integer modulo by 1, to avoid warning

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

Avoid race on mkdir

Should fix https://github.com/KhronosGroup/SPIRV-Tools/issues/340

Allow OpUndef appearing in the type and global variable section.

Also clean up API functions for adding instructions into the
type and global values section.

Add another construtor for opt::ir::Instruction

Test INotEqual for OpSpecConstantOp in asm, disasm

Add iterator getter interface for types_values_

OpUndef can appear in type declaration section

Turn off modifying methods for const iterators.

Clear old def-use record when re-analyze an ID

Add make_range() & make_const_range() for creating iterator ranges.

Avoid non-oneliner definition in class and add missing iterators.

Move the def-use analysis for single inst to public

Add getter for pointee, element type

Create an iterator class for in-memory representation.

Make the lookup up of type id accepts const arg

Reuse the iterator on Id and type lookup

Add the const version of AsXXtype() interface.

Add GetId(Type* type) API to the type manager

Avoid double-copy of NameMapper object.