Add .clang-format.

This allows automatic source-file formatting with clang-format, freeing
contributors from worrying about formatting while keeping the style
consistent everywhere.

.clang-format

@@ -0,0 +1,11 @@
+Language: Cpp
+IndentWidth: 4
+BreakBeforeBraces: Custom
+BraceWrapping: { AfterFunction: true }
+IndentCaseLabels: false
+ColumnLimit: 100
+AccessModifierOffset: -4
+AlignTrailingComments: true
+AllowShortBlocksOnASingleLine: false
+AllowShortIfStatementsOnASingleLine: false
+AllowShortLoopsOnASingleLine: false

SPIRV/SpvBuilder.cpp

@@ -1,11 +1,11 @@
 //
-//Copyright (C) 2014 LunarG, Inc.
+// Copyright (C) 2014 LunarG, Inc.
 //
-//All rights reserved.
+// All rights reserved.
 //
-//Redistribution and use in source and binary forms, with or without
-//modification, are permitted provided that the following conditions
-//are met:
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
 //
 //    Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
@@ -19,18 +19,18 @@
 //    contributors may be used to endorse or promote products derived
 //    from this software without specific prior written permission.
 //
-//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-//POSSIBILITY OF SUCH DAMAGE.
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
 
 //
 // Author: John Kessenich, LunarG
@@ -50,33 +50,30 @@
 #include "SpvBuilder.h"
 
 #ifndef _WIN32
-    #include <cstdio>
+#include <cstdio>
 #endif
 
 namespace spv {
 
-Builder::Builder(unsigned int magicNumber) :
-    source(SourceLanguageUnknown),
-    sourceVersion(0),
-    addressModel(AddressingModelLogical),
-    memoryModel(MemoryModelGLSL450),
-    builderNumber(magicNumber),
-    buildPoint(0),
-    uniqueId(0),
-    mainFunction(0)
+Builder::Builder(unsigned int magicNumber)
+    : source(SourceLanguageUnknown),
+      sourceVersion(0),
+      addressModel(AddressingModelLogical),
+      memoryModel(MemoryModelGLSL450),
+      builderNumber(magicNumber),
+      buildPoint(0),
+      uniqueId(0),
+      mainFunction(0)
 {
     clearAccessChain();
 }
 
-Builder::~Builder()
-{
-}
-
+Builder::~Builder() {}
 Id Builder::import(const char* name)
 {
     Instruction* import = new Instruction(getUniqueId(), NoType, OpExtInstImport);
     import->addStringOperand(name);
-    
+
     imports.push_back(import);
     return import->getResultId();
 }
@@ -219,8 +216,7 @@ Id Builder::makeStructResultType(Id type0, Id type1)
         type = groupedTypes[OpTypeStruct][t];
         if (type->getNumOperands() != 2)
             continue;
-        if (type->getIdOperand(0) != type0 || 
-            type->getIdOperand(1) != type1)
+        if (type->getIdOperand(0) != type0 || type->getIdOperand(1) != type1)
             continue;
         return type->getResultId();
     }
@@ -239,8 +235,7 @@ Id Builder::makeVectorType(Id component, int size)
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeVector].size(); ++t) {
         type = groupedTypes[OpTypeVector][t];
-        if (type->getIdOperand(0) == component &&
-            type->getImmediateOperand(1) == (unsigned)size)
+        if (type->getIdOperand(0) == component && type->getImmediateOperand(1) == (unsigned)size)
             return type->getResultId();
     }
 
@@ -265,8 +260,7 @@ Id Builder::makeMatrixType(Id component, int cols, int rows)
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeMatrix].size(); ++t) {
         type = groupedTypes[OpTypeMatrix][t];
-        if (type->getIdOperand(0) == column &&
-            type->getImmediateOperand(1) == (unsigned)cols)
+        if (type->getIdOperand(0) == column && type->getImmediateOperand(1) == (unsigned)cols)
             return type->getResultId();
     }
 
@@ -294,8 +288,7 @@ Id Builder::makeArrayType(Id element, unsigned size, int stride)
         // try to find existing type
         for (int t = 0; t < (int)groupedTypes[OpTypeArray].size(); ++t) {
             type = groupedTypes[OpTypeArray][t];
-            if (type->getIdOperand(0) == element &&
-                type->getIdOperand(1) == sizeId)
+            if (type->getIdOperand(0) == element && type->getIdOperand(1) == sizeId)
                 return type->getResultId();
         }
     }
@@ -327,7 +320,8 @@ Id Builder::makeFunctionType(Id returnType, std::vector<Id>& paramTypes)
     Instruction* type;
     for (int t = 0; t < (int)groupedTypes[OpTypeFunction].size(); ++t) {
         type = groupedTypes[OpTypeFunction][t];
-        if (type->getIdOperand(0) != returnType || (int)paramTypes.size() != type->getNumOperands() - 1)
+        if (type->getIdOperand(0) != returnType ||
+            (int)paramTypes.size() != type->getNumOperands() - 1)
             continue;
         bool mismatch = false;
         for (int p = 0; p < (int)paramTypes.size(); ++p) {
@@ -336,7 +330,7 @@ Id Builder::makeFunctionType(Id returnType, std::vector<Id>& paramTypes)
                 break;
             }
         }
-        if (! mismatch)
+        if (!mismatch)
             return type->getResultId();
     }
 
@@ -352,7 +346,8 @@ Id Builder::makeFunctionType(Id returnType, std::vector<Id>& paramTypes)
     return type->getResultId();
 }
 
-Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format)
+Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, bool ms,
+                          unsigned sampled, ImageFormat format)
 {
     // try to find it
     Instruction* type;
@@ -360,9 +355,9 @@ Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, boo
         type = groupedTypes[OpTypeImage][t];
         if (type->getIdOperand(0) == sampledType &&
             type->getImmediateOperand(1) == (unsigned int)dim &&
-            type->getImmediateOperand(2) == (  depth ? 1u : 0u) &&
+            type->getImmediateOperand(2) == (depth ? 1u : 0u) &&
             type->getImmediateOperand(3) == (arrayed ? 1u : 0u) &&
-            type->getImmediateOperand(4) == (     ms ? 1u : 0u) &&
+            type->getImmediateOperand(4) == (ms ? 1u : 0u) &&
             type->getImmediateOperand(5) == sampled &&
             type->getImmediateOperand(6) == (unsigned int)format)
             return type->getResultId();
@@ -371,10 +366,10 @@ Id Builder::makeImageType(Id sampledType, Dim dim, bool depth, bool arrayed, boo
     // not found, make it
     type = new Instruction(getUniqueId(), NoType, OpTypeImage);
     type->addIdOperand(sampledType);
-    type->addImmediateOperand(   dim);
-    type->addImmediateOperand(  depth ? 1 : 0);
+    type->addImmediateOperand(dim);
+    type->addImmediateOperand(depth ? 1 : 0);
     type->addImmediateOperand(arrayed ? 1 : 0);
-    type->addImmediateOperand(     ms ? 1 : 0);
+    type->addImmediateOperand(ms ? 1 : 0);
     type->addImmediateOperand(sampled);
     type->addImmediateOperand((unsigned int)format);
 
@@ -419,8 +414,7 @@ Op Builder::getMostBasicTypeClass(Id typeId) const
     Instruction* instr = module.getInstruction(typeId);
 
     Op typeClass = instr->getOpCode();
-    switch (typeClass)
-    {
+    switch (typeClass) {
     case OpTypeVoid:
     case OpTypeBool:
     case OpTypeInt:
@@ -444,8 +438,7 @@ int Builder::getNumTypeConstituents(Id typeId) const
 {
     Instruction* instr = module.getInstruction(typeId);
 
-    switch (instr->getOpCode())
-    {
+    switch (instr->getOpCode()) {
     case OpTypeBool:
     case OpTypeInt:
     case OpTypeFloat:
@@ -470,8 +463,7 @@ Id Builder::getScalarTypeId(Id typeId) const
     Instruction* instr = module.getInstruction(typeId);
 
     Op typeClass = instr->getOpCode();
-    switch (typeClass)
-    {
+    switch (typeClass) {
     case OpTypeVoid:
     case OpTypeBool:
     case OpTypeInt:
@@ -496,8 +488,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const
     Instruction* instr = module.getInstruction(typeId);
 
     Op typeClass = instr->getOpCode();
-    switch (typeClass)
-    {
+    switch (typeClass) {
     case OpTypeVector:
     case OpTypeMatrix:
     case OpTypeArray:
@@ -514,11 +505,7 @@ Id Builder::getContainedTypeId(Id typeId, int member) const
 }
 
 // Return the immediately contained type of a given composite type.
-Id Builder::getContainedTypeId(Id typeId) const
-{
-    return getContainedTypeId(typeId, 0);
-}
-
+Id Builder::getContainedTypeId(Id typeId) const { return getContainedTypeId(typeId, 0); }
 // See if a scalar constant of this type has already been created, so it
 // can be reused rather than duplicated.  (Required by the specification).
 Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned value) const
@@ -526,8 +513,7 @@ Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned valu
     Instruction* constant;
     for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) {
         constant = groupedConstants[typeClass][i];
-        if (constant->getOpCode() == opcode &&
-            constant->getTypeId() == typeId &&
+        if (constant->getOpCode() == opcode && constant->getTypeId() == typeId &&
             constant->getImmediateOperand(0) == value)
             return constant->getResultId();
     }
@@ -541,10 +527,8 @@ Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1,
     Instruction* constant;
     for (int i = 0; i < (int)groupedConstants[typeClass].size(); ++i) {
         constant = groupedConstants[typeClass][i];
-        if (constant->getOpCode() == opcode &&
-            constant->getTypeId() == typeId &&
-            constant->getImmediateOperand(0) == v1 &&
-            constant->getImmediateOperand(1) == v2)
+        if (constant->getOpCode() == opcode && constant->getTypeId() == typeId &&
+            constant->getImmediateOperand(0) == v1 && constant->getImmediateOperand(1) == v2)
             return constant->getResultId();
     }
 
@@ -557,7 +541,7 @@ Id Builder::findScalarConstant(Op typeClass, Op opcode, Id typeId, unsigned v1,
 bool Builder::isConstantOpCode(Op opcode) const
 {
     switch (opcode) {
-    case OpUndef: 
+    case OpUndef:
     case OpConstantTrue:
     case OpConstantFalse:
     case OpConstant:
@@ -579,7 +563,8 @@ Id Builder::makeBoolConstant(bool b, bool specConstant)
 {
     Id typeId = makeBoolType();
     Instruction* constant;
-    Op opcode = specConstant ? (b ? OpSpecConstantTrue : OpSpecConstantFalse) : (b ? OpConstantTrue : OpConstantFalse);
+    Op opcode = specConstant ? (b ? OpSpecConstantTrue : OpSpecConstantFalse)
+                             : (b ? OpConstantTrue : OpConstantFalse);
 
     // See if we already made it
     Id existing = 0;
@@ -675,7 +660,7 @@ Id Builder::findCompositeConstant(Op typeClass, std::vector<Id>& comps) const
                 break;
             }
         }
-        if (! mismatch) {
+        if (!mismatch) {
             found = true;
             break;
         }
@@ -728,7 +713,8 @@ Instruction* Builder::addEntryPoint(ExecutionModel model, Function* function, co
 }
 
 // Currently relying on the fact that all 'value' of interest are small non-negative values.
-void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, int value1, int value2, int value3)
+void Builder::addExecutionMode(Function* entryPoint, ExecutionMode mode, int value1, int value2,
+                               int value3)
 {
     Instruction* instr = new Instruction(OpExecutionMode);
     instr->addIdOperand(entryPoint->getId());
@@ -801,7 +787,7 @@ void Builder::addMemberDecoration(Id id, unsigned int member, Decoration decorat
 // Comments in header
 Function* Builder::makeMain()
 {
-    assert(! mainFunction);
+    assert(!mainFunction);
 
     Block* entry;
     std::vector<Id> params;
@@ -812,7 +798,8 @@ Function* Builder::makeMain()
 }
 
 // Comments in header
-Function* Builder::makeFunctionEntry(Id returnType, const char* name, std::vector<Id>& paramTypes, Block **entry)
+Function* Builder::makeFunctionEntry(Id returnType, const char* name, std::vector<Id>& paramTypes,
+                                     Block** entry)
 {
     Id typeId = makeFunctionType(returnType, paramTypes);
     Id firstParamId = paramTypes.size() == 0 ? 0 : getUniqueIds((int)paramTypes.size());
@@ -840,7 +827,7 @@ void Builder::makeReturn(bool implicit, Id retVal)
     } else
         buildPoint->addInstruction(new Instruction(NoResult, NoType, OpReturn));
 
-    if (! implicit)
+    if (!implicit)
         createAndSetNoPredecessorBlock("post-return");
 }
 
@@ -852,8 +839,7 @@ void Builder::leaveFunction()
     assert(block);
 
     // If our function did not contain a return, add a return void now.
-    if (! block->isTerminated()) {
-
+    if (!block->isTerminated()) {
         // Whether we're in an unreachable (non-entry) block.
         bool unreachable = function.getEntryBlock() != block && block->getNumPredecessors() == 0;
 
@@ -910,9 +896,9 @@ Id Builder::createVariable(StorageClass storageClass, Id type, const char* name)
 // Comments in header
 Id Builder::createUndefined(Id type)
 {
-  Instruction* inst = new Instruction(getUniqueId(), type, OpUndef);
-  buildPoint->addInstruction(inst);
-  return inst->getResultId();
+    Instruction* inst = new Instruction(getUniqueId(), type, OpUndef);
+    buildPoint->addInstruction(inst);
+    return inst->getResultId();
 }
 
 // Comments in header
@@ -1002,7 +988,8 @@ Id Builder::createCompositeInsert(Id object, Id composite, Id typeId, unsigned i
     return insert->getResultId();
 }
 
-Id Builder::createCompositeInsert(Id object, Id composite, Id typeId, std::vector<unsigned>& indexes)
+Id Builder::createCompositeInsert(Id object, Id composite, Id typeId,
+                                  std::vector<unsigned>& indexes)
 {
     Instruction* insert = new Instruction(getUniqueId(), typeId, OpCompositeInsert);
     insert->addIdOperand(object);
@@ -1182,9 +1169,11 @@ void Builder::promoteScalar(Decoration precision, Id& left, Id& right)
     int direction = getNumComponents(right) - getNumComponents(left);
 
     if (direction > 0)
-        left = smearScalar(precision, left, makeVectorType(getTypeId(left), getNumComponents(right)));
+        left =
+            smearScalar(precision, left, makeVectorType(getTypeId(left), getNumComponents(right)));
     else if (direction < 0)
-        right = smearScalar(precision, right, makeVectorType(getTypeId(right), getNumComponents(left)));
+        right =
+            smearScalar(precision, right, makeVectorType(getTypeId(right), getNumComponents(left)));
 
     return;
 }
@@ -1208,7 +1197,8 @@ Id Builder::smearScalar(Decoration /*precision*/, Id scalar, Id vectorType)
 }
 
 // Comments in header
-Id Builder::createBuiltinCall(Decoration /*precision*/, Id resultType, Id builtins, int entryPoint, std::vector<Id>& args)
+Id Builder::createBuiltinCall(Decoration /*precision*/, Id resultType, Id builtins, int entryPoint,
+                              std::vector<Id>& args)
 {
     Instruction* inst = new Instruction(getUniqueId(), resultType, OpExtInst);
     inst->addIdOperand(builtins);
@@ -1222,7 +1212,8 @@ Id Builder::createBuiltinCall(Decoration /*precision*/, Id resultType, Id builti
 
 // Accept all parameters needed to create a texture instruction.
 // Create the correct instruction based on the inputs, and make the call.
-Id Builder::createTextureCall(Decoration precision, Id resultType, bool fetch, bool proj, bool gather, const TextureParameters& parameters)
+Id Builder::createTextureCall(Decoration precision, Id resultType, bool fetch, bool proj,
+                              bool gather, const TextureParameters& parameters)
 {
     static const int maxTextureArgs = 10;
     Id texArgs[maxTextureArgs] = {};
@@ -1242,9 +1233,10 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool fetch, b
     //
     // Set up the optional arguments
     //
-    int optArgNum = numArgs;                        // track which operand, if it exists, is the mask of optional arguments
-    ++numArgs;                                      // speculatively make room for the mask operand
-    ImageOperandsMask mask = ImageOperandsMaskNone; // the mask operand
+    int optArgNum =
+        numArgs;  // track which operand, if it exists, is the mask of optional arguments
+    ++numArgs;    // speculatively make room for the mask operand
+    ImageOperandsMask mask = ImageOperandsMaskNone;  // the mask operand
     if (parameters.bias) {
         mask = (ImageOperandsMask)(mask | ImageOperandsBiasMask);
         texArgs[numArgs++] = parameters.bias;
@@ -1322,7 +1314,7 @@ Id Builder::createTextureCall(Decoration precision, Id resultType, bool fetch, b
     // This happens when a legacy shadow*() call is made, which
     // gets a vec4 back instead of a float.
     Id smearedType = resultType;
-    if (! isScalarType(resultType)) {
+    if (!isScalarType(resultType)) {
         switch (opCode) {
         case OpImageSampleDrefImplicitLod:
         case OpImageSampleDrefExplicitLod:
@@ -1363,8 +1355,7 @@ Id Builder::createTextureQueryCall(Op opCode, const TextureParameters& parameter
     Id resultType = 0;
     switch (opCode) {
     case OpImageQuerySize:
-    case OpImageQuerySizeLod:
-    {
+    case OpImageQuerySizeLod: {
         int numComponents;
         switch (getTypeDimensionality(getImageType(parameters.sampler))) {
         case Dim1D:
@@ -1480,7 +1471,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b
         if (constituent == 0)
             resultId = subResultId;
         else
-            resultId = createBinOp(equal ? OpLogicalAnd : OpLogicalOr, boolType, resultId, subResultId);
+            resultId =
+                createBinOp(equal ? OpLogicalAnd : OpLogicalOr, boolType, resultId, subResultId);
     }
 
     return resultId;
@@ -1489,7 +1481,8 @@ Id Builder::createCompositeCompare(Decoration precision, Id value1, Id value2, b
 // OpCompositeConstruct
 Id Builder::createCompositeConstruct(Id typeId, std::vector<Id>& constituents)
 {
-    assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 && getNumTypeConstituents(typeId) == (int)constituents.size()));
+    assert(isAggregateType(typeId) || (getNumTypeConstituents(typeId) > 1 &&
+                                       getNumTypeConstituents(typeId) == (int)constituents.size()));
 
     Instruction* op = new Instruction(getUniqueId(), typeId, OpCompositeConstruct);
     for (int c = 0; c < (int)constituents.size(); ++c)
@@ -1514,7 +1507,7 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
     Id scalarTypeId = getScalarTypeId(resultTypeId);
     std::vector<Id> constituents;  // accumulate the arguments for OpCompositeConstruct
     for (unsigned int i = 0; i < sources.size(); ++i) {
-        assert(! isAggregate(sources[i]));
+        assert(!isAggregate(sources[i]));
         unsigned int sourceSize = getNumComponents(sources[i]);
         unsigned int sourcesToUse = sourceSize;
         if (sourcesToUse + targetComponent > numTargetComponents)
@@ -1548,7 +1541,8 @@ Id Builder::createConstructor(Decoration precision, const std::vector<Id>& sourc
 }
 
 // Comments in header
-Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>& sources, Id resultTypeId)
+Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>& sources,
+                                    Id resultTypeId)
 {
     Id componentTypeId = getScalarTypeId(resultTypeId);
     int numCols = getTypeNumColumns(resultTypeId);
@@ -1562,7 +1556,7 @@ Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>&
 
     // initialize the array to the identity matrix
     Id ids[maxMatrixSize][maxMatrixSize];
-    Id  one = makeFloatConstant(1.0);
+    Id one = makeFloatConstant(1.0);
     Id zero = makeFloatConstant(0.0);
     for (int col = 0; col < 4; ++col) {
         for (int row = 0; row < 4; ++row) {
@@ -1579,7 +1573,8 @@ Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>&
         for (int col = 0; col < 4; ++col)
             ids[col][col] = sources[0];
     } else if (isMatrix(sources[0])) {
-        // constructing from another matrix; copy over the parts that exist in both the argument and constructee
+        // constructing from another matrix; copy over the parts that exist in both the argument and
+        // constructee
         Id matrix = sources[0];
         int minCols = std::min(numCols, getNumColumns(matrix));
         int minRows = std::min(numRows, getNumRows(matrix));
@@ -1614,7 +1609,6 @@ Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>&
         }
     }
 
-
     // Step 2:  Construct a matrix from that array.
     // First make the column vectors, then make the matrix.
 
@@ -1633,10 +1627,7 @@ Id Builder::createMatrixConstructor(Decoration precision, const std::vector<Id>&
 }
 
 // Comments in header
-Builder::If::If(Id cond, Builder& gb) :
-    builder(gb),
-    condition(cond),
-    elseBlock(0)
+Builder::If::If(Id cond, Builder& gb) : builder(gb), condition(cond), elseBlock(0)
 {
     function = &builder.getBuildPoint()->getParent();
 
@@ -1688,7 +1679,8 @@ void Builder::If::makeEndIf()
 }
 
 // Comments in header
-void Builder::makeSwitch(Id selector, int numSegments, std::vector<int>& caseValues, std::vector<int>& valueIndexToSegment, int defaultSegment,
+void Builder::makeSwitch(Id selector, int numSegments, std::vector<int>& caseValues,
+                         std::vector<int>& valueIndexToSegment, int defaultSegment,
                          std::vector<Block*>& segmentBlocks)
 {
     Function& function = buildPoint->getParent();
@@ -1705,7 +1697,8 @@ void Builder::makeSwitch(Id selector, int numSegments, std::vector<int>& caseVal
     // make the switch instruction
     Instruction* switchInst = new Instruction(NoResult, NoType, OpSwitch);
     switchInst->addIdOperand(selector);
-    switchInst->addIdOperand(defaultSegment >= 0 ? segmentBlocks[defaultSegment]->getId() : mergeBlock->getId());
+    switchInst->addIdOperand(defaultSegment >= 0 ? segmentBlocks[defaultSegment]->getId()
+                                                 : mergeBlock->getId());
     for (int i = 0; i < (int)caseValues.size(); ++i) {
         switchInst->addImmediateOperand(caseValues[i]);
         switchInst->addIdOperand(segmentBlocks[valueIndexToSegment[i]]->getId());
@@ -1730,7 +1723,7 @@ void Builder::nextSwitchSegment(std::vector<Block*>& segmentBlock, int nextSegme
     int lastSegment = nextSegment - 1;
     if (lastSegment >= 0) {
         // Close out previous segment by jumping, if necessary, to next segment
-        if (! buildPoint->isTerminated())
+        if (!buildPoint->isTerminated())
             createBranch(segmentBlock[nextSegment]);
     }
     Block* block = segmentBlock[nextSegment];
@@ -1742,7 +1735,7 @@ void Builder::nextSwitchSegment(std::vector<Block*>& segmentBlock, int nextSegme
 void Builder::endSwitch(std::vector<Block*>& /*segmentBlock*/)
 {
     // Close out previous segment by jumping, if necessary, to next segment
-    if (! buildPoint->isTerminated())
+    if (!buildPoint->isTerminated())
         addSwitchBreak();
 
     switchMerges.top()->getParent().addBlock(switchMerges.top());
@@ -1944,13 +1937,15 @@ void Builder::accessChainStore(Id rvalue)
     Id source = NoResult;
     if (accessChain.swizzle.size()) {
         Id tempBaseId = createLoad(base);
-        source = createLvalueSwizzle(getTypeId(tempBaseId), tempBaseId, rvalue, accessChain.swizzle);
+        source =
+            createLvalueSwizzle(getTypeId(tempBaseId), tempBaseId, rvalue, accessChain.swizzle);
     }
 
     // dynamic component selection
     if (accessChain.component != NoResult) {
         Id tempBaseId = (source == NoResult) ? createLoad(base) : source;
-        source = createVectorInsertDynamic(tempBaseId, getTypeId(tempBaseId), rvalue, accessChain.component);
+        source = createVectorInsertDynamic(tempBaseId, getTypeId(tempBaseId), rvalue,
+                                           accessChain.component);
     }
 
     if (source == NoResult)
@@ -1968,8 +1963,10 @@ Id Builder::accessChainLoad(Id resultType)
         // transfer access chain, but keep it static, so we can stay in registers
         transferAccessChainSwizzle(false);
         if (accessChain.indexChain.size() > 0) {
-            Id swizzleBase = accessChain.preSwizzleBaseType != NoType ? accessChain.preSwizzleBaseType : resultType;
-        
+            Id swizzleBase = accessChain.preSwizzleBaseType != NoType
+                                 ? accessChain.preSwizzleBaseType
+                                 : resultType;
+
             // if all the accesses are constants, we can use OpCompositeExtract
             std::vector<unsigned> indexes;
             bool constant = true;
@@ -1986,7 +1983,8 @@ Id Builder::accessChainLoad(Id resultType)
                 id = createCompositeExtract(accessChain.base, swizzleBase, indexes);
             else {
                 // make a new function variable for this r-value
-                Id lValue = createVariable(StorageClassFunction, getTypeId(accessChain.base), "indexable");
+                Id lValue =
+                    createVariable(StorageClassFunction, getTypeId(accessChain.base), "indexable");
 
                 // store into it
                 createStore(accessChain.base, lValue);
@@ -2111,8 +2109,10 @@ Id Builder::collapseAccessChain()
 
     if (accessChain.indexChain.size() > 0) {
         if (accessChain.instr == 0) {
-            StorageClass storageClass = (StorageClass)module.getStorageClass(getTypeId(accessChain.base));
-            accessChain.instr = createAccessChain(storageClass, accessChain.base, accessChain.indexChain);
+            StorageClass storageClass =
+                (StorageClass)module.getStorageClass(getTypeId(accessChain.base));
+            accessChain.instr =
+                createAccessChain(storageClass, accessChain.base, accessChain.indexChain);
         }
 
         return accessChain.instr;
@@ -2194,7 +2194,7 @@ void Builder::createAndSetNoPredecessorBlock(const char* /*name*/)
     buildPoint->getParent().addBlock(block);
     setBuildPoint(block);
 
-    //if (name)
+    // if (name)
     //    addName(block->getId(), name);
 }
 
@@ -2235,7 +2235,8 @@ void Builder::createConditionalBranch(Id condition, Block* thenBlock, Block* els
     elseBlock->addPredecessor(buildPoint);
 }
 
-void Builder::dumpInstructions(std::vector<unsigned int>& out, const std::vector<Instruction*>& instructions) const
+void Builder::dumpInstructions(std::vector<unsigned int>& out,
+                               const std::vector<Instruction*>& instructions) const
 {
     for (int i = 0; i < (int)instructions.size(); ++i) {
         instructions[i]->dump(out);
@@ -2252,29 +2253,24 @@ void TbdFunctionality(const char* tbd)
     }
 }
 
-void MissingFunctionality(const char* fun)
-{
-    printf("Missing functionality: %s\n", fun);
-}
-
+void MissingFunctionality(const char* fun) { printf("Missing functionality: %s\n", fun); }
 Builder::Loop::Loop(Builder& builder, bool testFirstArg)
-  : function(&builder.getBuildPoint()->getParent()),
-    header(new Block(builder.getUniqueId(), *function)),
-    merge(new Block(builder.getUniqueId(), *function)),
-    body(new Block(builder.getUniqueId(), *function)),
-    testFirst(testFirstArg),
-    isFirstIteration(nullptr)
-{
-    if (!testFirst)
-    {
-// You may be tempted to rewrite this as
-// new Instruction(builder.getUniqueId(), builder.makeBoolType(), OpPhi);
-// This will cause subtle test failures because builder.getUniqueId(),
-// and builder.makeBoolType() can then get run in a compiler-specific
-// order making tests fail for certain configurations.
+    : function(&builder.getBuildPoint()->getParent()),
+      header(new Block(builder.getUniqueId(), *function)),
+      merge(new Block(builder.getUniqueId(), *function)),
+      body(new Block(builder.getUniqueId(), *function)),
+      testFirst(testFirstArg),
+      isFirstIteration(nullptr)
+{
+    if (!testFirst) {
+        // You may be tempted to rewrite this as
+        // new Instruction(builder.getUniqueId(), builder.makeBoolType(), OpPhi);
+        // This will cause subtle test failures because builder.getUniqueId(),
+        // and builder.makeBoolType() can then get run in a compiler-specific
+        // order making tests fail for certain configurations.
         Id instructionId = builder.getUniqueId();
         isFirstIteration = new Instruction(instructionId, builder.makeBoolType(), OpPhi);
     }
 }
 
-}; // end spv namespace
+};  // end spv namespace

SPIRV/SpvBuilder.h

@@ -1,11 +1,11 @@
 //
-//Copyright (C) 2014 LunarG, Inc.
+// Copyright (C) 2014 LunarG, Inc.
 //
-//All rights reserved.
+// All rights reserved.
 //
-//Redistribution and use in source and binary forms, with or without
-//modification, are permitted provided that the following conditions
-//are met:
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
 //
 //    Redistributions of source code must retain the above copyright
 //    notice, this list of conditions and the following disclaimer.
@@ -19,18 +19,18 @@
 //    contributors may be used to endorse or promote products derived
 //    from this software without specific prior written permission.
 //
-//THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 //"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-//LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-//FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-//COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-//INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-//BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-//LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-//CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-//LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-//ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-//POSSIBILITY OF SUCH DAMAGE.
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+// BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+// ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+// POSSIBILITY OF SUCH DAMAGE.
 
 //
 // Author: John Kessenich, LunarG
@@ -52,8 +52,8 @@
 #include "spvIR.h"
 
 #include <algorithm>
-#include <stack>
 #include <map>
+#include <stack>
 
 namespace spv {
 
@@ -78,10 +78,8 @@ public:
     }
 
     void addCapability(spv::Capability cap) { capabilities.push_back(cap); }
-
     // To get a new <id> for anything needing a new one.
     Id getUniqueId() { return ++uniqueId; }
-
     // To get a set of new <id>s, e.g., for a set of function parameters
     Id getUniqueIds(int numIds)
     {
@@ -94,7 +92,7 @@ public:
     Id makeVoidType();
     Id makeBoolType();
     Id makePointer(StorageClass, Id type);
-    Id makeIntegerType(int width, bool hasSign);   // generic
+    Id makeIntegerType(int width, bool hasSign);  // generic
     Id makeIntType(int width) { return makeIntegerType(width, true); }
     Id makeUintType(int width) { return makeIntegerType(width, false); }
     Id makeFloatType(int width);
@@ -105,7 +103,8 @@ public:
     Id makeArrayType(Id element, unsigned size, int stride);  // 0 means no stride decoration
     Id makeRuntimeArray(Id element);
     Id makeFunctionType(Id returnType, std::vector<Id>& paramTypes);
-    Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled, ImageFormat format);
+    Id makeImageType(Id sampledType, Dim, bool depth, bool arrayed, bool ms, unsigned sampled,
+                     ImageFormat format);
     Id makeSamplerType();
     Id makeSampledImageType(Id imageType);
 
@@ -122,31 +121,42 @@ public:
     Id getContainedTypeId(Id typeId) const;
     Id getContainedTypeId(Id typeId, int) const;
     StorageClass getTypeStorageClass(Id typeId) const { return module.getStorageClass(typeId); }
-
-    bool isPointer(Id resultId)      const { return isPointerType(getTypeId(resultId)); }
-    bool isScalar(Id resultId)       const { return isScalarType(getTypeId(resultId)); }
-    bool isVector(Id resultId)       const { return isVectorType(getTypeId(resultId)); }
-    bool isMatrix(Id resultId)       const { return isMatrixType(getTypeId(resultId)); }
-    bool isAggregate(Id resultId)    const { return isAggregateType(getTypeId(resultId)); }
+    bool isPointer(Id resultId) const { return isPointerType(getTypeId(resultId)); }
+    bool isScalar(Id resultId) const { return isScalarType(getTypeId(resultId)); }
+    bool isVector(Id resultId) const { return isVectorType(getTypeId(resultId)); }
+    bool isMatrix(Id resultId) const { return isMatrixType(getTypeId(resultId)); }
+    bool isAggregate(Id resultId) const { return isAggregateType(getTypeId(resultId)); }
     bool isSampledImage(Id resultId) const { return isSampledImageType(getTypeId(resultId)); }
-
-    bool isBoolType(Id typeId)         const { return groupedTypes[OpTypeBool].size() > 0 && typeId == groupedTypes[OpTypeBool].back()->getResultId(); }
-    bool isPointerType(Id typeId)      const { return getTypeClass(typeId) == OpTypePointer; }
-    bool isScalarType(Id typeId)       const { return getTypeClass(typeId) == OpTypeFloat  || getTypeClass(typeId) == OpTypeInt || getTypeClass(typeId) == OpTypeBool; }
-    bool isVectorType(Id typeId)       const { return getTypeClass(typeId) == OpTypeVector; }
-    bool isMatrixType(Id typeId)       const { return getTypeClass(typeId) == OpTypeMatrix; }
-    bool isStructType(Id typeId)       const { return getTypeClass(typeId) == OpTypeStruct; }
-    bool isArrayType(Id typeId)        const { return getTypeClass(typeId) == OpTypeArray; }
-    bool isAggregateType(Id typeId)    const { return isArrayType(typeId) || isStructType(typeId); }
-    bool isImageType(Id typeId)        const { return getTypeClass(typeId) == OpTypeImage; }
-    bool isSamplerType(Id typeId)      const { return getTypeClass(typeId) == OpTypeSampler; }
+    bool isBoolType(Id typeId) const
+    {
+        return groupedTypes[OpTypeBool].size() > 0 &&
+               typeId == groupedTypes[OpTypeBool].back()->getResultId();
+    }
+    bool isPointerType(Id typeId) const { return getTypeClass(typeId) == OpTypePointer; }
+    bool isScalarType(Id typeId) const
+    {
+        return getTypeClass(typeId) == OpTypeFloat || getTypeClass(typeId) == OpTypeInt ||
+               getTypeClass(typeId) == OpTypeBool;
+    }
+    bool isVectorType(Id typeId) const { return getTypeClass(typeId) == OpTypeVector; }
+    bool isMatrixType(Id typeId) const { return getTypeClass(typeId) == OpTypeMatrix; }
+    bool isStructType(Id typeId) const { return getTypeClass(typeId) == OpTypeStruct; }
+    bool isArrayType(Id typeId) const { return getTypeClass(typeId) == OpTypeArray; }
+    bool isAggregateType(Id typeId) const { return isArrayType(typeId) || isStructType(typeId); }
+    bool isImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeImage; }
+    bool isSamplerType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampler; }
     bool isSampledImageType(Id typeId) const { return getTypeClass(typeId) == OpTypeSampledImage; }
-
     bool isConstantOpCode(Op opcode) const;
     bool isConstant(Id resultId) const { return isConstantOpCode(getOpCode(resultId)); }
     bool isConstantScalar(Id resultId) const { return getOpCode(resultId) == OpConstant; }
-    unsigned int getConstantScalar(Id resultId) const { return module.getInstruction(resultId)->getImmediateOperand(0); }
-    StorageClass getStorageClass(Id resultId) const { return getTypeStorageClass(getTypeId(resultId)); }
+    unsigned int getConstantScalar(Id resultId) const
+    {
+        return module.getInstruction(resultId)->getImmediateOperand(0);
+    }
+    StorageClass getStorageClass(Id resultId) const
+    {
+        return getTypeStorageClass(getTypeId(resultId));
+    }
 
     int getTypeNumColumns(Id typeId) const
     {
@@ -160,7 +170,6 @@ public:
         return getNumTypeComponents(getContainedTypeId(typeId));
     }
     int getNumRows(Id resultId) const { return getTypeNumRows(getTypeId(resultId)); }
-
     Dim getTypeDimensionality(Id typeId) const
     {
         assert(isImageType(typeId));
@@ -180,8 +189,14 @@ public:
 
     // For making new constants (will return old constant if the requested one was already made).
     Id makeBoolConstant(bool b, bool specConstant = false);
-    Id makeIntConstant(int i, bool specConstant = false)         { return makeIntConstant(makeIntType(32),  (unsigned)i, specConstant); }
-    Id makeUintConstant(unsigned u, bool specConstant = false)   { return makeIntConstant(makeUintType(32),           u, specConstant); }
+    Id makeIntConstant(int i, bool specConstant = false)
+    {
+        return makeIntConstant(makeIntType(32), (unsigned)i, specConstant);
+    }
+    Id makeUintConstant(unsigned u, bool specConstant = false)
+    {
+        return makeIntConstant(makeUintType(32), u, specConstant);
+    }
     Id makeFloatConstant(float f, bool specConstant = false);
     Id makeDoubleConstant(double d, bool specConstant = false);
 
@@ -190,7 +205,8 @@ public:
 
     // Methods for adding information outside the CFG.
     Instruction* addEntryPoint(ExecutionModel, Function*, const char* name);
-    void addExecutionMode(Function*, ExecutionMode mode, int value1 = -1, int value2 = -1, int value3 = -1);
+    void addExecutionMode(Function*, ExecutionMode mode, int value1 = -1, int value2 = -1,
+                          int value3 = -1);
     void addName(Id, const char* name);
     void addMemberName(Id, int member, const char* name);
     void addLine(Id target, Id fileName, int line, int column);
@@ -200,13 +216,13 @@ public:
     // At the end of what block do the next create*() instructions go?
     void setBuildPoint(Block* bp) { buildPoint = bp; }
     Block* getBuildPoint() const { return buildPoint; }
-
     // Make the main function.
     Function* makeMain();
 
     // Make a shader-style function, and create its entry block if entry is non-zero.
     // Return the function, pass back the entry.
-    Function* makeFunctionEntry(Id returnType, const char* name, std::vector<Id>& paramTypes, Block **entry = 0);
+    Function* makeFunctionEntry(Id returnType, const char* name, std::vector<Id>& paramTypes,
+                                Block** entry = 0);
 
     // Create a return. An 'implicit' return is one not appearing in the source
     // code.  In the case of an implicit return, no post-return block is inserted.
@@ -271,7 +287,7 @@ public:
     void setPrecision(Id /* value */, Decoration precision)
     {
         if (precision != NoPrecision) {
-            ;// TODO
+            ;  // TODO
         }
     }
 
@@ -282,10 +298,11 @@ public:
     //   - promoteScalar(scalar, scalar)  // do nothing
     // Other forms are not allowed.
     //
-    // Generally, the type of 'scalar' does not need to be the same type as the components in 'vector'.
+    // Generally, the type of 'scalar' does not need to be the same type as the components in
+    // 'vector'.
     // The type of the created vector is a vector of components of the same type as the scalar.
     //
-    // Note: One of the arguments will change, with the result coming back that way rather than 
+    // Note: One of the arguments will change, with the result coming back that way rather than
     // through the return value.
     void promoteScalar(Decoration precision, Id& left, Id& right);
 
@@ -295,7 +312,8 @@ public:
     Id smearScalar(Decoration precision, Id scalarVal, Id vectorType);
 
     // Create a call to a built-in function.
-    Id createBuiltinCall(Decoration precision, Id resultType, Id builtins, int entryPoint, std::vector<Id>& args);
+    Id createBuiltinCall(Decoration precision, Id resultType, Id builtins, int entryPoint,
+                         std::vector<Id>& args);
 
     // List of parameters used to create a texture operation
     struct TextureParameters {
@@ -313,7 +331,8 @@ public:
     };
 
     // Select the correct texture operation based on all inputs, and emit the correct instruction
-    Id createTextureCall(Decoration precision, Id resultType, bool fetch, bool proj, bool gather, const TextureParameters&);
+    Id createTextureCall(Decoration precision, Id resultType, bool fetch, bool proj, bool gather,
+                         const TextureParameters&);
 
     // Emit the OpTextureQuery* instruction that was passed in.
     // Figure out the right return value and type, and return it.
@@ -325,7 +344,8 @@ public:
     Id createBitFieldInsertCall(Decoration precision, Id, Id, Id, Id);
 
     // Reduction comparision for composites:  For equal and not-equal resulting in a scalar.
-    Id createCompositeCompare(Decoration precision, Id, Id, bool /* true if for equal, false if for not-equal */);
+    Id createCompositeCompare(Decoration precision, Id, Id,
+                              bool /* true if for equal, false if for not-equal */);
 
     // OpCompositeConstruct
     Id createCompositeConstruct(Id typeId, std::vector<Id>& constituents);
@@ -334,14 +354,14 @@ public:
     Id createConstructor(Decoration precision, const std::vector<Id>& sources, Id resultTypeId);
 
     // matrix constructor
-    Id createMatrixConstructor(Decoration precision, const std::vector<Id>& sources, Id constructee);
+    Id createMatrixConstructor(Decoration precision, const std::vector<Id>& sources,
+                               Id constructee);
 
     // Helper to use for building nested control flow with if-then-else.
     class If {
     public:
         If(Id condition, Builder& builder);
         ~If() {}
-
         void makeBeginElse();
         void makeEndIf();
 
@@ -370,7 +390,8 @@ public:
     // Returns the right set of basic blocks to start each code segment with, so that the caller's
     // recursion stack can hold the memory for it.
     //
-    void makeSwitch(Id condition, int numSegments, std::vector<int>& caseValues, std::vector<int>& valueToSegment, int defaultSegment,
+    void makeSwitch(Id condition, int numSegments, std::vector<int>& caseValues,
+                    std::vector<int>& valueToSegment, int defaultSegment,
                     std::vector<Block*>& segmentBB);  // return argument
 
     // Add a branch to the innermost switch's merge block.
@@ -440,13 +461,16 @@ public:
     //
 
     struct AccessChain {
-        Id base;                       // for l-values, pointer to the base object, for r-values, the base object
+        Id base;  // for l-values, pointer to the base object, for r-values, the base object
         std::vector<Id> indexChain;
-        Id instr;                      // cache the instruction that generates this access chain
-        std::vector<unsigned> swizzle; // each std::vector element selects the next GLSL component number
-        Id component;                  // a dynamic component index, can coexist with a swizzle, done after the swizzle, NoResult if not present
-        Id preSwizzleBaseType;         // dereferenced type, before swizzle or component is applied; NoType unless a swizzle or component is present
-        bool isRValue;                 // true if 'base' is an r-value, otherwise, base is an l-value
+        Id instr;  // cache the instruction that generates this access chain
+        std::vector<unsigned>
+            swizzle;   // each std::vector element selects the next GLSL component number
+        Id component;  // a dynamic component index, can coexist with a swizzle, done after the
+                       // swizzle, NoResult if not present
+        Id preSwizzleBaseType;  // dereferenced type, before swizzle or component is applied; NoType
+                                // unless a swizzle or component is present
+        bool isRValue;          // true if 'base' is an r-value, otherwise, base is an l-value
     };
 
     //
@@ -457,7 +481,6 @@ public:
     // for external save and restore
     AccessChain getAccessChain() { return accessChain; }
     void setAccessChain(AccessChain newChain) { accessChain = newChain; }
-
     // clear accessChain
     void clearAccessChain();
 
@@ -476,11 +499,7 @@ public:
     }
 
     // push offset onto the end of the chain
-    void accessChainPush(Id offset)
-    {
-        accessChain.indexChain.push_back(offset);
-    }
-
+    void accessChainPush(Id offset) { accessChain.indexChain.push_back(offset); }
     // push new swizzle onto the end of any existing swizzle, merging into a single swizzle
     void accessChainPushSwizzle(std::vector<unsigned>& swizzle, Id preSwizzleBaseType);
 
@@ -518,7 +537,7 @@ protected:
     void createConditionalBranch(Id condition, Block* thenBlock, Block* elseBlock);
     void dumpInstructions(std::vector<unsigned int>&, const std::vector<Instruction*>&) const;
 
-    struct Loop; // Defined below.
+    struct Loop;  // Defined below.
     void createBranchToLoopHeaderFromInside(const Loop& loop);
 
     SourceLanguage source;
@@ -544,7 +563,7 @@ protected:
     std::vector<Instruction*> constantsTypesGlobals;
     std::vector<Instruction*> externals;
 
-     // not output, internally used for quick & dirty canonical (unique) creation
+    // not output, internally used for quick & dirty canonical (unique) creation
     std::vector<Instruction*> groupedConstants[OpConstant];  // all types appear before OpConstant
     std::vector<Instruction*> groupedTypes[OpConstant];
 
@@ -602,4 +621,4 @@ void MissingFunctionality(const char*);
 
 };  // end spv namespace
 
-#endif // SpvBuilder_H
+#endif  // SpvBuilder_H