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.

Use friendly names for Ids

Add spirv-cfg to dump a GraphViz graph of the CFG

This is experimental, and has not tests.
It's been used to debug validation of structured control flow.

- Has a legend describing special arcs to merge blocks and continue
  targets.
- Labels the function entry block, with the Id of the function.

Add back the missing msg about --eliminate-dead-const

Fix build error about passing initializer-list to constructor.

VS2013 is not happy with using initializer-list to initialize
vector parameters to explicit constructors taking one vector.

Make type manager RAII-like w.r.t. the module to be analyzed.

Optimization: Add type manager.

Type manager will construct a map of types gradually from
instructions.

Optimization: Add type class hierarchy.

Appveyor: also test on Visual Studio 2013.

Fix paths in the README.

Change the interfaces of in-memory representation to use pointers.

Previously we use vectors of objects and move semantics to handle
ownership. That approach has the flaw that inserting an object into
the middle of a vector, which may trigger a vector reallocation,
can invalidate some addresses taken from instructions.

Now the in-memory representation internally uses vector of unique
pointers to handle ownership. Since objects are explicitly heap-
allocated now, pointers to them won't be invalidated by vector
resizing anymore.

Update CHANGES to say issue 288 is fixed

Fixed the build for MSVC.

assembly_builder was missing an include for cstdint.

Manually create move the constructor/assignment for Instruction.

This is because some old visual studio versions (e.g., 2013) do
not support automatically generating move constructors/assignments.

Fix compilation. My bad

The API changed, and I forgot to submit this patch.

Check dominance of OpPhi parent and variable pairs

Removed dead code/const_casts/lists

Separate pass.h from passes.h

Future pass implementations should only need to include pass.h

Use NEW behavior for policy CMP0054.

The NEW behavior is to not dereference variables or interpret keywords
that have been quoted or bracketed.

For more information, see
https://cmake.org/cmake/help/v3.1/policy/CMP0054.html.

This is to suppress a warning when using CMake 3.1.3+.

Refactor Id -> Instruction

Fix minor mistakes in the tests of dead-const-elim

Print the shader when module building failed

Dead constant elimination

A pass to remove dead constants, including both front-end constants and spec
constants.

This pass does not handle dead variables and types.

Remove unnecessary headers