commit	f2e1440116da114bf2ec5738c07dfe97703101eb	[log] [tgz]
author	Lei Zhang <antiagainst@google.com>	Tue Jul 19 18:42:34 2016 -0400
committer	Lei Zhang <antiagainst@google.com>	Tue Jul 19 18:43:15 2016 -0400
tree	d607f662d000ebfe2644082cbc60345019339463
parent	9fc206608c21434e765daaca7c52410f60263bfa [diff]
parent	934855a64236dcad8c56b563734ffbbffb22abba [diff]

Merge remote-tracking branch 'aosp/upstream-master'

Pulls in the following:
934855a Fix issue #382: Detect implicitly-sized atomic_uint arrays.
f2cfe27 Fix issue #388.
31a51be Fix issue #391: input stack underflow on too few macro arguments.
f833250 Merge pull request #395 from steve-lunarg/samplers
5d58fae HLSL: Add tx.GetDimensions method (uint returns only)
e4821e4 Build: Fix three new warnings in HLSL code.
35dcbbe Merge pull request #390 from steve-lunarg/samplers
4016e38 Build: Switch to Rev. 6 of headers, removing "BadValue" enum stuff.
a2b7991 HLSL: Add SampleBias and SampleGrad, and associated tests
efb89a3 Merge pull request #392 from antiagainst/order
b1165f4 Reorder fields to avoid compiler initialization order error.
51e74b1 Merge pull request #385 from steve-lunarg/inout-qualifiers
83f05a0 Merge pull request #387 from steve-lunarg/samplers
92aff54 HLSL: add offset Sample() form and arrayed texture support
9249c70 HLSL: add in/out/inout qualifiers.
f02bea2 Merge pull request #380 from steve-lunarg/samplers
4886f69 HLSL: Sampler/texture declarations, method syntax, partial Sample method
d8509b3 Front-end: Implement compile-time constant folding for any() and all().
91b7533 README: remove reference to todo.txt, it is obsolete.
a86836e Front-end: Fix known crashes by early exit on error (issue #29, issue #34, issue #35).
75b0316 Build: Add missing string.h include.
7f349c7 Build: Remove causes of pedantic warnings. Addresses issue #352 and PR #242.
c45ddda Merge pull request #314 from mre4ce/master
b501a75 Front end: Fix issue #374: put a limit on how big a type name can get.
78a4557 SPV: Fix issue #376; declare Geometry capability for fragment use of gl_Layer.
91e4aa5 SPV: Further refine OpenGL vs. Vulkan differences for SPIR-V.
2d0cc78 SPV: Turn on atomic-storage functionality for SPIR-V.
5e69ec6 HLSL: Add typedef grammar and production.
d5ed0b6 HLSL: Mostly non-functional: simplify, rationalize, and generalize the declaration grammar.
0735424 HLSL: Grammar: Recognize { } style initializers for composites.
b0a63f5 HLSL: Correctly identify which variables are global storage class.
532543c HLSL: Grammar: Make comma-separated declaration lists work.
92d44b1 Merge pull request #367 from steve-lunarg/templatetypes
6daaa4f HLSL: Add template style constructors for vector & matrix types
d02dc5d HLSL: Implement switch/case/default.
2f47bc9 SPV: Don't decorate locations within an array, it doesn't make sense.
6090df0 SPV: Non-functional: break up big function into three smaller ones.
266b1d3 Merge pull request #363 from cdwfs/vertex_instance_id
f5dcdf0 Front-end: Don't lower precision of bit operations taking highp inputs.
ae3e773 Merge pull request #364 from steve-lunarg/test-entrypoints
e903ab5 HLSL: Change intrinsics tests to not use overloaded entry points
85028e1 When parsing Vulkan GLSL, suggest gl_VertexIndex/gl_InstanceIndex instead of gl_VertexID/gl_InstanceID.
af151f9 Merge pull request #358 from amdrexu/bugfix
c884b4a SPV: Certain decorations are missing for structure-typed in/out variables.
187254b Merge pull request #357 from steve-lunarg/intrinsics
7c8b743 Merge pull request #267 from antiagainst/rm-test-dup
bc17b0a Front-end: Add missing rule for function-return implicit type conversion check.
b10feab Front-end: Non-functional: Move return-value handling from .y to .cpp.
1011971 Front-end: Handle simultaneous use of SPIR-V or non-SPIR-V.
48e296b Remove duplicated tests from the runtests script.
1b7fd0f Add asdouble, fma, & mad intrinsics and change profile to allow doubles when parsing prototypes
e5a8072 Merge pull request #349 from steve-lunarg/intrinsics
22bca55 Merge pull request #354 from yavn/fix_off_by_one_limit_check
5bc4d9a HLSL: Airplane work: break/continue/discard grammar, and decls for for/if/while.
bbbcb5b Front-end: allow max size built-in arrays like gl_ClipDistance
4624a02 Add lerp, fix sincos return type, ret type tests, non-square mats, HLSL->AST tx semantics
a4a4d5e Merge pull request #346 from steve-lunarg/intrinsics
6e72fdd Add HLSL memory barrier intrinsics, fix dst, add lit & EvaluateAttributeSnapped
1fd0175 turn -x into an option next to -o
ecb0f3b Added -x option to save SPIR-V as 32-bit hexadecimal numbers to a text file.

Change-Id: I3a3cc98a50c36f542b3d7470691cb7c193ad8e43

tree: d607f662d000ebfe2644082cbc60345019339463

README.md

Also see the Khronos landing page for glslang as a reference front end:

https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/

The above page includes where to get binaries, and is kept up to date regarding the feature level of glslang.

glslang

An OpenGL and OpenGL ES shader front end and validator.

There are two components:

A front-end library for programmatic parsing of GLSL/ESSL into an AST.
A standalone wrapper, glslangValidator, that can be used as a shader validation tool.

How to add a feature protected by a version/extension/stage/profile: See the comment in glslang/MachineIndependent/Versions.cpp.

Tasks waiting to be done are documented as GitHub issues.

Execution of Standalone Wrapper

To use the standalone binary form, execute glslangValidator, and it will print a usage statement. Basic operation is to give it a file containing a shader, and it will print out warnings/errors and optionally an AST.

The applied stage-specific rules are based on the file extension:

.vert for a vertex shader
.tesc for a tessellation control shader
.tese for a tessellation evaluation shader
.geom for a geometry shader
.frag for a fragment shader
.comp for a compute shader

There is also a non-shader extension

.conf for a configuration file of limits, see usage statement for example

Building

Dependencies

CMake: for generating compilation targets.
bison: optional, but needed when changing the grammar (glslang.y).
googletest: optional, but should use if making any changes to glslang.

Build steps

1) Check-Out External Projects

cd <the directory glslang was cloned to, External will be a subdirectory>
git clone https://github.com/google/googletest.git External/googletest

2) Configure

Assume the source directory is $SOURCE_DIR and the build directory is $BUILD_DIR:

For building on Linux (assuming using the Ninja generator):

cd $BUILD_DIR

cmake -GNinja -DCMAKE_BUILD_TYPE={Debug|Release|RelWithDebInfo} \
      -DCMAKE_INSTALL_PREFIX=`pwd`/install $SOURCE_DIR

For building on Windows:

cmake $SOURCE_DIR -DCMAKE_INSTALL_PREFIX=`pwd`/install
# The CMAKE_INSTALL_PREFIX part is for testing (explained later).

The CMake GUI also works for Windows (version 3.4.1 tested).

3) Build and Install

# for Linux:
ninja install

# for Windows:
cmake --build . --config {Release|Debug|MinSizeRel|RelWithDebInfo} \
      --target install

If using MSVC, after running CMake to configure, use the Configuration Manager to check the INSTALL project.

If you need to change the GLSL grammar

The grammar in glslang/MachineIndependent/glslang.y has to be recompiled with bison if it changes, the output files are committed to the repo to avoid every developer needing to have bison configured to compile the project when grammar changes are quite infrequent. For windows you can get binaries from GnuWin32.

The command to rebuild is:

bison --defines=MachineIndependent/glslang_tab.cpp.h
      -t MachineIndependent/glslang.y
      -o MachineIndependent/glslang_tab.cpp

The above command is also available in the bash script at glslang/updateGrammar.

Testing

Right now, there are two test harnesses existing in glslang: one is Google Test, one is the runtests script. The former runs unit tests and single-shader single-threaded integration tests, while the latter runs multiple-shader linking tests and multi-threaded tests.

Running tests

The runtests script requires compiled binaries to be installed into $BUILD_DIR/install. Please make sure you have supplied the correct configuration to CMake (using -DCMAKE_INSTALL_PREFIX) when building; otherwise, you may want to modify the path in the runtests script.

Running Google Test-backed tests:

cd $BUILD_DIR

# for Linux:
ctest

# for Windows:
ctest -C {Debug|Release|RelWithDebInfo|MinSizeRel}

# or, run the test binary directly
# (which gives more fine-grained control like filtering):
<dir-to-glslangtests-in-build-dir>/glslangtests

Running runtests script-backed tests:

cd $SOURCE_DIR/Test && ./runtests

Contributing tests

Test results should always be included with a pull request that modifies functionality.

If you are writing unit tests, please use the Google Test framework and place the tests under the gtests/ directory.

Integration tests are placed in the Test/ directory. It contains test input and a subdirectory baseResults/ that contains the expected results of the tests. Both the tests and baseResults/ are under source-code control.

Google Test runs those integration tests by reading the test input, compiling them, and then compare against the expected results in baseResults/. The integration tests to run via Google Test is registered in various gtests/*.FromFile.cpp source files. glslangtests provides a command-line option --update-mode, which, if supplied, will overwrite the golden files under the baseResults/ directory with real output from that invocation. For more information, please check gtests/ directory's README.

For the runtests script, it will generate current results in the localResults/ directory and diff them against the baseResults/. When you want to update the tracked test results, they need to be copied from localResults/ to baseResults/. This can be done by the bump shell script.

You can add your own private list of tests, not tracked publicly, by using localtestlist to list non-tracked tests. This is automatically read by runtests and included in the diff and bump process.

Programmatic Interfaces

Another piece of software can programmatically translate shaders to an AST using one of two different interfaces:

A new C++ class-oriented interface, or
The original C functional interface

The main() in StandAlone/StandAlone.cpp shows examples using both styles.

C++ Class Interface (new, preferred)

This interface is in roughly the last 1/3 of ShaderLang.h. It is in the glslang namespace and contains the following.

const char* GetEsslVersionString();
const char* GetGlslVersionString();
bool InitializeProcess();
void FinalizeProcess();

class TShader
    bool parse(...);
    void setStrings(...);
    const char* getInfoLog();

class TProgram
    void addShader(...);
    bool link(...);
    const char* getInfoLog();
    Reflection queries

See ShaderLang.h and the usage of it in StandAlone/StandAlone.cpp for more details.

C Functional Interface (orignal)

This interface is in roughly the first 2/3 of ShaderLang.h, and referred to as the Sh*() interface, as all the entry points start Sh.

The Sh*() interface takes a “compiler” call-back object, which it calls after building call back that is passed the AST and can then execute a backend on it.

The following is a simplified resulting run-time call stack:

ShCompile(shader, compiler) -> compiler(AST) -> <back end>

In practice, ShCompile() takes shader strings, default version, and warning/error and other options for controlling compilation.

Basic Internal Operation

Initial lexical analysis is done by the preprocessor in MachineIndependent/Preprocessor, and then refined by a GLSL scanner in MachineIndependent/Scan.cpp. There is currently no use of flex.
Code is parsed using bison on MachineIndependent/glslang.y with the aid of a symbol table and an AST. The symbol table is not passed on to the back-end; the intermediate representation stands on its own. The tree is built by the grammar productions, many of which are offloaded into ParseHelper.cpp, and by Intermediate.cpp.
The intermediate representation is very high-level, and represented as an in-memory tree. This serves to lose no information from the original program, and to have efficient transfer of the result from parsing to the back-end. In the AST, constants are propogated and folded, and a very small amount of dead code is eliminated.
To aid linking and reflection, the last top-level branch in the AST lists all global symbols.
The primary algorithm of the back-end compiler is to traverse the tree (high-level intermediate representation), and create an internal object code representation. There is an example of how to do this in MachineIndependent/intermOut.cpp.
Reduction of the tree to a linear byte-code style low-level intermediate representation is likely a good way to generate fully optimized code.
There is currently some dead old-style linker-type code still lying around.
Memory pool: parsing uses types derived from C++ std types, using a custom allocator that puts them in a memory pool. This makes allocation of individual container/contents just few cycles and deallocation free. This pool is popped after the AST is made and processed.
The use is simple: if you are going to call new, there are three cases:
- the object comes from the pool (its base class has the macro POOL_ALLOCATOR_NEW_DELETE in it) and you do not have to call delete
- it is a TString, in which case call NewPoolTString(), which gets it from the pool, and there is no corresponding delete
- the object does not come from the pool, and you have to do normal C++ memory management of what you new