| 1 |
# News |
| 2 |
|
| 3 |
1. Visual Studio 2013 is no longer supported |
| 4 |
|
| 5 |
[As scheduled](https://github.com/KhronosGroup/glslang/blob/9eef54b2513ca6b40b47b07d24f453848b65c0df/README.md#planned-deprecationsremovals), |
| 6 |
Microsoft Visual Studio 2013 is no longer officially supported. \ |
| 7 |
Please upgrade to at least Visual Studio 2015. |
| 8 |
|
| 9 |
2. The versioning scheme is being improved, and you might notice some differences. This is currently WIP, but will be coming soon. See, for example, PR #2277. |
| 10 |
|
| 11 |
3. If you get a new **compilation error due to a missing header**, it might be caused by this planned removal: |
| 12 |
|
| 13 |
**SPIRV Folder, 1-May, 2020.** Glslang, when installed through CMake, |
| 14 |
will install a `SPIRV` folder into `${CMAKE_INSTALL_INCLUDEDIR}`. |
| 15 |
This `SPIRV` folder is being moved to `glslang/SPIRV`. |
| 16 |
During the transition the `SPIRV` folder will be installed into both locations. |
| 17 |
The old install of `SPIRV/` will be removed as a CMake install target no sooner than May 1, 2020. |
| 18 |
See issue #1964. |
| 19 |
|
| 20 |
If people are only using this location to get spirv.hpp, I recommend they get that from [SPIRV-Headers](https://github.com/KhronosGroup/SPIRV-Headers) instead. |
| 21 |
|
| 22 |
[](https://travis-ci.org/KhronosGroup/glslang) |
| 23 |
[](https://ci.appveyor.com/project/Khronoswebmaster/glslang/branch/master) |
| 24 |
|
| 25 |
# Glslang Components and Status |
| 26 |
|
| 27 |
There are several components: |
| 28 |
|
| 29 |
### Reference Validator and GLSL/ESSL -> AST Front End |
| 30 |
|
| 31 |
An OpenGL GLSL and OpenGL|ES GLSL (ESSL) front-end for reference validation and translation of GLSL/ESSL into an internal abstract syntax tree (AST). |
| 32 |
|
| 33 |
**Status**: Virtually complete, with results carrying similar weight as the specifications. |
| 34 |
|
| 35 |
### HLSL -> AST Front End |
| 36 |
|
| 37 |
An HLSL front-end for translation of an approximation of HLSL to glslang's AST form. |
| 38 |
|
| 39 |
**Status**: Partially complete. Semantics are not reference quality and input is not validated. |
| 40 |
This is in contrast to the [DXC project](https://github.com/Microsoft/DirectXShaderCompiler), which receives a much larger investment and attempts to have definitive/reference-level semantics. |
| 41 |
|
| 42 |
See [issue 362](https://github.com/KhronosGroup/glslang/issues/362) and [issue 701](https://github.com/KhronosGroup/glslang/issues/701) for current status. |
| 43 |
|
| 44 |
### AST -> SPIR-V Back End |
| 45 |
|
| 46 |
Translates glslang's AST to the Khronos-specified SPIR-V intermediate language. |
| 47 |
|
| 48 |
**Status**: Virtually complete. |
| 49 |
|
| 50 |
### Reflector |
| 51 |
|
| 52 |
An API for getting reflection information from the AST, reflection types/variables/etc. from the HLL source (not the SPIR-V). |
| 53 |
|
| 54 |
**Status**: There is a large amount of functionality present, but no specification/goal to measure completeness against. It is accurate for the input HLL and AST, but only approximate for what would later be emitted for SPIR-V. |
| 55 |
|
| 56 |
### Standalone Wrapper |
| 57 |
|
| 58 |
`glslangValidator` is command-line tool for accessing the functionality above. |
| 59 |
|
| 60 |
Status: Complete. |
| 61 |
|
| 62 |
Tasks waiting to be done are documented as GitHub issues. |
| 63 |
|
| 64 |
## Other References |
| 65 |
|
| 66 |
Also see the Khronos landing page for glslang as a reference front end: |
| 67 |
|
| 68 |
https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/ |
| 69 |
|
| 70 |
The above page, while not kept up to date, includes additional information regarding glslang as a reference validator. |
| 71 |
|
| 72 |
# How to Use Glslang |
| 73 |
|
| 74 |
## Execution of Standalone Wrapper |
| 75 |
|
| 76 |
To use the standalone binary form, execute `glslangValidator`, and it will print |
| 77 |
a usage statement. Basic operation is to give it a file containing a shader, |
| 78 |
and it will print out warnings/errors and optionally an AST. |
| 79 |
|
| 80 |
The applied stage-specific rules are based on the file extension: |
| 81 |
* `.vert` for a vertex shader |
| 82 |
* `.tesc` for a tessellation control shader |
| 83 |
* `.tese` for a tessellation evaluation shader |
| 84 |
* `.geom` for a geometry shader |
| 85 |
* `.frag` for a fragment shader |
| 86 |
* `.comp` for a compute shader |
| 87 |
|
| 88 |
There is also a non-shader extension |
| 89 |
* `.conf` for a configuration file of limits, see usage statement for example |
| 90 |
|
| 91 |
## Building (CMake) |
| 92 |
|
| 93 |
Instead of building manually, you can also download the binaries for your |
| 94 |
platform directly from the [master-tot release][master-tot-release] on GitHub. |
| 95 |
Those binaries are automatically uploaded by the buildbots after successful |
| 96 |
testing and they always reflect the current top of the tree of the master |
| 97 |
branch. |
| 98 |
|
| 99 |
### Dependencies |
| 100 |
|
| 101 |
* A C++11 compiler. |
| 102 |
(For MSVS: use 2015 or later.) |
| 103 |
* [CMake][cmake]: for generating compilation targets. |
| 104 |
* make: _Linux_, ninja is an alternative, if configured. |
| 105 |
* [Python 3.x][python]: for executing SPIRV-Tools scripts. (Optional if not using SPIRV-Tools and the 'External' subdirectory does not exist.) |
| 106 |
* [bison][bison]: _optional_, but needed when changing the grammar (glslang.y). |
| 107 |
* [googletest][googletest]: _optional_, but should use if making any changes to glslang. |
| 108 |
|
| 109 |
### Build steps |
| 110 |
|
| 111 |
The following steps assume a Bash shell. On Windows, that could be the Git Bash |
| 112 |
shell or some other shell of your choosing. |
| 113 |
|
| 114 |
#### 1) Check-Out this project |
| 115 |
|
| 116 |
```bash |
| 117 |
cd <parent of where you want glslang to be> |
| 118 |
git clone https://github.com/KhronosGroup/glslang.git |
| 119 |
``` |
| 120 |
|
| 121 |
#### 2) Check-Out External Projects |
| 122 |
|
| 123 |
```bash |
| 124 |
cd <the directory glslang was cloned to, "External" will be a subdirectory> |
| 125 |
git clone https://github.com/google/googletest.git External/googletest |
| 126 |
``` |
| 127 |
|
| 128 |
If you wish to assure that SPIR-V generated from HLSL is legal for Vulkan, |
| 129 |
wish to invoke -Os to reduce SPIR-V size from HLSL or GLSL, or wish to run the |
| 130 |
integrated test suite, install spirv-tools with this: |
| 131 |
|
| 132 |
```bash |
| 133 |
./update_glslang_sources.py |
| 134 |
``` |
| 135 |
|
| 136 |
#### 3) Configure |
| 137 |
|
| 138 |
Assume the source directory is `$SOURCE_DIR` and the build directory is |
| 139 |
`$BUILD_DIR`. First ensure the build directory exists, then navigate to it: |
| 140 |
|
| 141 |
```bash |
| 142 |
mkdir -p $BUILD_DIR |
| 143 |
cd $BUILD_DIR |
| 144 |
``` |
| 145 |
|
| 146 |
For building on Linux: |
| 147 |
|
| 148 |
```bash |
| 149 |
cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX="$(pwd)/install" $SOURCE_DIR |
| 150 |
# "Release" (for CMAKE_BUILD_TYPE) could also be "Debug" or "RelWithDebInfo" |
| 151 |
``` |
| 152 |
|
| 153 |
For building on Android: |
| 154 |
```bash |
| 155 |
cmake $SOURCE_DIR -G "Unix Makefiles" -DCMAKE_INSTALL_PREFIX="$(pwd)/install" -DANDROID_ABI=arm64-v8a -DCMAKE_BUILD_TYPE=Release -DANDROID_STL=c++_static -DANDROID_PLATFORM=android-24 -DCMAKE_SYSTEM_NAME=Android -DANDROID_TOOLCHAIN=clang -DANDROID_ARM_MODE=arm -DCMAKE_MAKE_PROGRAM=$ANDROID_NDK_ROOT/prebuilt/linux-x86_64/bin/make -DCMAKE_TOOLCHAIN_FILE=$ANDROID_NDK_ROOT/build/cmake/android.toolchain.cmake |
| 156 |
# If on Windows will be -DCMAKE_MAKE_PROGRAM=%ANDROID_NDK_ROOT%\prebuilt\windows-x86_64\bin\make.exe |
| 157 |
# -G is needed for building on Windows |
| 158 |
# -DANDROID_ABI can also be armeabi-v7a for 32 bit |
| 159 |
``` |
| 160 |
|
| 161 |
For building on Windows: |
| 162 |
|
| 163 |
```bash |
| 164 |
cmake $SOURCE_DIR -DCMAKE_INSTALL_PREFIX="$(pwd)/install" |
| 165 |
# The CMAKE_INSTALL_PREFIX part is for testing (explained later). |
| 166 |
``` |
| 167 |
|
| 168 |
The CMake GUI also works for Windows (version 3.4.1 tested). |
| 169 |
|
| 170 |
Also, consider using `git config --global core.fileMode false` (or with `--local`) on Windows |
| 171 |
to prevent the addition of execution permission on files. |
| 172 |
|
| 173 |
#### 4) Build and Install |
| 174 |
|
| 175 |
```bash |
| 176 |
# for Linux: |
| 177 |
make -j4 install |
| 178 |
|
| 179 |
# for Windows: |
| 180 |
cmake --build . --config Release --target install |
| 181 |
# "Release" (for --config) could also be "Debug", "MinSizeRel", or "RelWithDebInfo" |
| 182 |
``` |
| 183 |
|
| 184 |
If using MSVC, after running CMake to configure, use the |
| 185 |
Configuration Manager to check the `INSTALL` project. |
| 186 |
|
| 187 |
### Building (GN) |
| 188 |
|
| 189 |
glslang can also be built with the [GN build system](https://gn.googlesource.com/gn/). |
| 190 |
|
| 191 |
#### 1) Install `depot_tools` |
| 192 |
|
| 193 |
Download [depot_tools.zip](https://storage.googleapis.com/chrome-infra/depot_tools.zip), |
| 194 |
extract to a directory, and add this directory to your `PATH`. |
| 195 |
|
| 196 |
#### 2) Synchronize dependencies and generate build files |
| 197 |
|
| 198 |
This only needs to be done once after updating `glslang`. |
| 199 |
|
| 200 |
With the current directory set to your `glslang` checkout, type: |
| 201 |
|
| 202 |
```bash |
| 203 |
./update_glslang_sources.py |
| 204 |
gclient sync --gclientfile=standalone.gclient |
| 205 |
gn gen out/Default |
| 206 |
``` |
| 207 |
|
| 208 |
#### 3) Build |
| 209 |
|
| 210 |
With the current directory set to your `glslang` checkout, type: |
| 211 |
|
| 212 |
```bash |
| 213 |
cd out/Default |
| 214 |
ninja |
| 215 |
``` |
| 216 |
|
| 217 |
### If you need to change the GLSL grammar |
| 218 |
|
| 219 |
The grammar in `glslang/MachineIndependent/glslang.y` has to be recompiled with |
| 220 |
bison if it changes, the output files are committed to the repo to avoid every |
| 221 |
developer needing to have bison configured to compile the project when grammar |
| 222 |
changes are quite infrequent. For windows you can get binaries from |
| 223 |
[GnuWin32][bison-gnu-win32]. |
| 224 |
|
| 225 |
The command to rebuild is: |
| 226 |
|
| 227 |
```bash |
| 228 |
m4 -P MachineIndependent/glslang.m4 > MachineIndependent/glslang.y |
| 229 |
bison --defines=MachineIndependent/glslang_tab.cpp.h |
| 230 |
-t MachineIndependent/glslang.y |
| 231 |
-o MachineIndependent/glslang_tab.cpp |
| 232 |
``` |
| 233 |
|
| 234 |
The above commands are also available in the bash script in `updateGrammar`, |
| 235 |
when executed from the glslang subdirectory of the glslang repository. |
| 236 |
With no arguments it builds the full grammar, and with a "web" argument, |
| 237 |
the web grammar subset (see more about the web subset in the next section). |
| 238 |
|
| 239 |
### Building to WASM for the Web and Node |
| 240 |
### Building a standalone JS/WASM library for the Web and Node |
| 241 |
|
| 242 |
Use the steps in [Build Steps](#build-steps), with the following notes/exceptions: |
| 243 |
* `emsdk` needs to be present in your executable search path, *PATH* for |
| 244 |
Bash-like environments: |
| 245 |
+ [Instructions located here](https://emscripten.org/docs/getting_started/downloads.html#sdk-download-and-install) |
| 246 |
* Wrap cmake call: `emcmake cmake` |
| 247 |
* Set `-DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF`. |
| 248 |
* Set `-DENABLE_HLSL=OFF` if HLSL is not needed. |
| 249 |
* For a standalone JS/WASM library, turn on `-DENABLE_GLSLANG_JS=ON`. |
| 250 |
* For building a minimum-size web subset of core glslang: |
| 251 |
+ turn on `-DENABLE_GLSLANG_WEBMIN=ON` (disables HLSL) |
| 252 |
+ execute `updateGrammar web` from the glslang subdirectory |
| 253 |
(or if using your own scripts, `m4` needs a `-DGLSLANG_WEB` argument) |
| 254 |
+ optionally, for GLSL compilation error messages, turn on |
| 255 |
`-DENABLE_GLSLANG_WEBMIN_DEVEL=ON` |
| 256 |
* To get a fully minimized build, make sure to use `brotli` to compress the .js |
| 257 |
and .wasm files |
| 258 |
|
| 259 |
Example: |
| 260 |
|
| 261 |
```sh |
| 262 |
emcmake cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_GLSLANG_JS=ON \ |
| 263 |
-DENABLE_HLSL=OFF -DBUILD_TESTING=OFF -DENABLE_OPT=OFF -DINSTALL_GTEST=OFF .. |
| 264 |
``` |
| 265 |
|
| 266 |
## Building glslang - Using vcpkg |
| 267 |
|
| 268 |
You can download and install glslang using the [vcpkg](https://github.com/Microsoft/vcpkg) dependency manager: |
| 269 |
|
| 270 |
git clone https://github.com/Microsoft/vcpkg.git |
| 271 |
cd vcpkg |
| 272 |
./bootstrap-vcpkg.sh |
| 273 |
./vcpkg integrate install |
| 274 |
./vcpkg install glslang |
| 275 |
|
| 276 |
The glslang port in vcpkg is kept up to date by Microsoft team members and community contributors. If the version is out of date, please [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the vcpkg repository. |
| 277 |
|
| 278 |
## Testing |
| 279 |
|
| 280 |
Right now, there are two test harnesses existing in glslang: one is [Google |
| 281 |
Test](gtests/), one is the [`runtests` script](Test/runtests). The former |
| 282 |
runs unit tests and single-shader single-threaded integration tests, while |
| 283 |
the latter runs multiple-shader linking tests and multi-threaded tests. |
| 284 |
|
| 285 |
### Running tests |
| 286 |
|
| 287 |
The [`runtests` script](Test/runtests) requires compiled binaries to be |
| 288 |
installed into `$BUILD_DIR/install`. Please make sure you have supplied the |
| 289 |
correct configuration to CMake (using `-DCMAKE_INSTALL_PREFIX`) when building; |
| 290 |
otherwise, you may want to modify the path in the `runtests` script. |
| 291 |
|
| 292 |
Running Google Test-backed tests: |
| 293 |
|
| 294 |
```bash |
| 295 |
cd $BUILD_DIR |
| 296 |
|
| 297 |
# for Linux: |
| 298 |
ctest |
| 299 |
|
| 300 |
# for Windows: |
| 301 |
ctest -C {Debug|Release|RelWithDebInfo|MinSizeRel} |
| 302 |
|
| 303 |
# or, run the test binary directly |
| 304 |
# (which gives more fine-grained control like filtering): |
| 305 |
<dir-to-glslangtests-in-build-dir>/glslangtests |
| 306 |
``` |
| 307 |
|
| 308 |
Running `runtests` script-backed tests: |
| 309 |
|
| 310 |
```bash |
| 311 |
cd $SOURCE_DIR/Test && ./runtests |
| 312 |
``` |
| 313 |
|
| 314 |
If some tests fail with validation errors, there may be a mismatch between the |
| 315 |
version of `spirv-val` on the system and the version of glslang. In this |
| 316 |
case, it is necessary to run `update_glslang_sources.py`. See "Check-Out |
| 317 |
External Projects" above for more details. |
| 318 |
|
| 319 |
### Contributing tests |
| 320 |
|
| 321 |
Test results should always be included with a pull request that modifies |
| 322 |
functionality. |
| 323 |
|
| 324 |
If you are writing unit tests, please use the Google Test framework and |
| 325 |
place the tests under the `gtests/` directory. |
| 326 |
|
| 327 |
Integration tests are placed in the `Test/` directory. It contains test input |
| 328 |
and a subdirectory `baseResults/` that contains the expected results of the |
| 329 |
tests. Both the tests and `baseResults/` are under source-code control. |
| 330 |
|
| 331 |
Google Test runs those integration tests by reading the test input, compiling |
| 332 |
them, and then compare against the expected results in `baseResults/`. The |
| 333 |
integration tests to run via Google Test is registered in various |
| 334 |
`gtests/*.FromFile.cpp` source files. `glslangtests` provides a command-line |
| 335 |
option `--update-mode`, which, if supplied, will overwrite the golden files |
| 336 |
under the `baseResults/` directory with real output from that invocation. |
| 337 |
For more information, please check `gtests/` directory's |
| 338 |
[README](gtests/README.md). |
| 339 |
|
| 340 |
For the `runtests` script, it will generate current results in the |
| 341 |
`localResults/` directory and `diff` them against the `baseResults/`. |
| 342 |
When you want to update the tracked test results, they need to be |
| 343 |
copied from `localResults/` to `baseResults/`. This can be done by |
| 344 |
the `bump` shell script. |
| 345 |
|
| 346 |
You can add your own private list of tests, not tracked publicly, by using |
| 347 |
`localtestlist` to list non-tracked tests. This is automatically read |
| 348 |
by `runtests` and included in the `diff` and `bump` process. |
| 349 |
|
| 350 |
## Programmatic Interfaces |
| 351 |
|
| 352 |
Another piece of software can programmatically translate shaders to an AST |
| 353 |
using one of two different interfaces: |
| 354 |
* A new C++ class-oriented interface, or |
| 355 |
* The original C functional interface |
| 356 |
|
| 357 |
The `main()` in `StandAlone/StandAlone.cpp` shows examples using both styles. |
| 358 |
|
| 359 |
### C++ Class Interface (new, preferred) |
| 360 |
|
| 361 |
This interface is in roughly the last 1/3 of `ShaderLang.h`. It is in the |
| 362 |
glslang namespace and contains the following, here with suggested calls |
| 363 |
for generating SPIR-V: |
| 364 |
|
| 365 |
```cxx |
| 366 |
const char* GetEsslVersionString(); |
| 367 |
const char* GetGlslVersionString(); |
| 368 |
bool InitializeProcess(); |
| 369 |
void FinalizeProcess(); |
| 370 |
|
| 371 |
class TShader |
| 372 |
setStrings(...); |
| 373 |
setEnvInput(EShSourceHlsl or EShSourceGlsl, stage, EShClientVulkan or EShClientOpenGL, 100); |
| 374 |
setEnvClient(EShClientVulkan or EShClientOpenGL, EShTargetVulkan_1_0 or EShTargetVulkan_1_1 or EShTargetOpenGL_450); |
| 375 |
setEnvTarget(EShTargetSpv, EShTargetSpv_1_0 or EShTargetSpv_1_3); |
| 376 |
bool parse(...); |
| 377 |
const char* getInfoLog(); |
| 378 |
|
| 379 |
class TProgram |
| 380 |
void addShader(...); |
| 381 |
bool link(...); |
| 382 |
const char* getInfoLog(); |
| 383 |
Reflection queries |
| 384 |
``` |
| 385 |
|
| 386 |
For just validating (not generating code), substitute these calls: |
| 387 |
|
| 388 |
```cxx |
| 389 |
setEnvInput(EShSourceHlsl or EShSourceGlsl, stage, EShClientNone, 0); |
| 390 |
setEnvClient(EShClientNone, 0); |
| 391 |
setEnvTarget(EShTargetNone, 0); |
| 392 |
``` |
| 393 |
|
| 394 |
See `ShaderLang.h` and the usage of it in `StandAlone/StandAlone.cpp` for more |
| 395 |
details. There is a block comment giving more detail above the calls for |
| 396 |
`setEnvInput, setEnvClient, and setEnvTarget`. |
| 397 |
|
| 398 |
### C Functional Interface (original) |
| 399 |
|
| 400 |
This interface is in roughly the first 2/3 of `ShaderLang.h`, and referred to |
| 401 |
as the `Sh*()` interface, as all the entry points start `Sh`. |
| 402 |
|
| 403 |
The `Sh*()` interface takes a "compiler" call-back object, which it calls after |
| 404 |
building call back that is passed the AST and can then execute a back end on it. |
| 405 |
|
| 406 |
The following is a simplified resulting run-time call stack: |
| 407 |
|
| 408 |
```c |
| 409 |
ShCompile(shader, compiler) -> compiler(AST) -> <back end> |
| 410 |
``` |
| 411 |
|
| 412 |
In practice, `ShCompile()` takes shader strings, default version, and |
| 413 |
warning/error and other options for controlling compilation. |
| 414 |
|
| 415 |
## Basic Internal Operation |
| 416 |
|
| 417 |
* Initial lexical analysis is done by the preprocessor in |
| 418 |
`MachineIndependent/Preprocessor`, and then refined by a GLSL scanner |
| 419 |
in `MachineIndependent/Scan.cpp`. There is currently no use of flex. |
| 420 |
|
| 421 |
* Code is parsed using bison on `MachineIndependent/glslang.y` with the |
| 422 |
aid of a symbol table and an AST. The symbol table is not passed on to |
| 423 |
the back-end; the intermediate representation stands on its own. |
| 424 |
The tree is built by the grammar productions, many of which are |
| 425 |
offloaded into `ParseHelper.cpp`, and by `Intermediate.cpp`. |
| 426 |
|
| 427 |
* The intermediate representation is very high-level, and represented |
| 428 |
as an in-memory tree. This serves to lose no information from the |
| 429 |
original program, and to have efficient transfer of the result from |
| 430 |
parsing to the back-end. In the AST, constants are propagated and |
| 431 |
folded, and a very small amount of dead code is eliminated. |
| 432 |
|
| 433 |
To aid linking and reflection, the last top-level branch in the AST |
| 434 |
lists all global symbols. |
| 435 |
|
| 436 |
* The primary algorithm of the back-end compiler is to traverse the |
| 437 |
tree (high-level intermediate representation), and create an internal |
| 438 |
object code representation. There is an example of how to do this |
| 439 |
in `MachineIndependent/intermOut.cpp`. |
| 440 |
|
| 441 |
* Reduction of the tree to a linear byte-code style low-level intermediate |
| 442 |
representation is likely a good way to generate fully optimized code. |
| 443 |
|
| 444 |
* There is currently some dead old-style linker-type code still lying around. |
| 445 |
|
| 446 |
* Memory pool: parsing uses types derived from C++ `std` types, using a |
| 447 |
custom allocator that puts them in a memory pool. This makes allocation |
| 448 |
of individual container/contents just few cycles and deallocation free. |
| 449 |
This pool is popped after the AST is made and processed. |
| 450 |
|
| 451 |
The use is simple: if you are going to call `new`, there are three cases: |
| 452 |
|
| 453 |
- the object comes from the pool (its base class has the macro |
| 454 |
`POOL_ALLOCATOR_NEW_DELETE` in it) and you do not have to call `delete` |
| 455 |
|
| 456 |
- it is a `TString`, in which case call `NewPoolTString()`, which gets |
| 457 |
it from the pool, and there is no corresponding `delete` |
| 458 |
|
| 459 |
- the object does not come from the pool, and you have to do normal |
| 460 |
C++ memory management of what you `new` |
| 461 |
|
| 462 |
* Features can be protected by version/extension/stage/profile: |
| 463 |
See the comment in `glslang/MachineIndependent/Versions.cpp`. |
| 464 |
|
| 465 |
[cmake]: https://cmake.org/ |
| 466 |
[python]: https://www.python.org/ |
| 467 |
[bison]: https://www.gnu.org/software/bison/ |
| 468 |
[googletest]: https://github.com/google/googletest |
| 469 |
[bison-gnu-win32]: http://gnuwin32.sourceforge.net/packages/bison.htm |
| 470 |
[master-tot-release]: https://github.com/KhronosGroup/glslang/releases/tag/master-tot |