src/compiler/translator/ShaderStorageBlockOutputHLSL.cpp - platform/external/angle - Git at Google

 //
 // Copyright 2018 The ANGLE Project Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 //
 // ShaderStorageBlockOutputHLSL: A traverser to translate a ssbo_access_chain to an offset of
 // RWByteAddressBuffer.
 //     //EOpIndexDirectInterfaceBlock
 //     ssbo_variable :=
 //       | the name of the SSBO
 //       | the name of a variable in an SSBO backed interface block

 //     // EOpIndexInDirect
 //     // EOpIndexDirect
 //     ssbo_array_indexing := ssbo_access_chain[expr_no_ssbo]

 //     // EOpIndexDirectStruct
 //     ssbo_structure_access := ssbo_access_chain.identifier

 //     ssbo_access_chain :=
 //       | ssbo_variable
 //       | ssbo_array_indexing
 //       | ssbo_structure_access
 //

 #include "compiler/translator/ShaderStorageBlockOutputHLSL.h"

 #include "compiler/translator/ResourcesHLSL.h"
 #include "compiler/translator/blocklayoutHLSL.h"
 #include "compiler/translator/tree_util/IntermNode_util.h"
 #include "compiler/translator/util.h"

 namespace sh
 {

 namespace
 {

 constexpr const char kShaderStorageDeclarationString[] =
     "// @@ SHADER STORAGE DECLARATION STRING @@";

 void GetBlockLayoutInfo(TIntermTyped *node,
                         bool rowMajorAlreadyAssigned,
                         TLayoutBlockStorage *storage,
                         bool *rowMajor)
 {
     TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
     if (swizzleNode)
     {
         return GetBlockLayoutInfo(swizzleNode->getOperand(), rowMajorAlreadyAssigned, storage,
                                   rowMajor);
     }

     TIntermBinary *binaryNode = node->getAsBinaryNode();
     if (binaryNode)
     {
         switch (binaryNode->getOp())
         {
             case EOpIndexDirectInterfaceBlock:
             {
                 // The column_major/row_major qualifier of a field member overrides the interface
                 // block's row_major/column_major. So we can assign rowMajor here and don't need to
                 // assign it again. But we still need to call recursively to get the storage's
                 // value.
                 const TType &type = node->getType();
                 *rowMajor         = type.getLayoutQualifier().matrixPacking == EmpRowMajor;
                 return GetBlockLayoutInfo(binaryNode->getLeft(), true, storage, rowMajor);
             }
             case EOpIndexIndirect:
             case EOpIndexDirect:
             case EOpIndexDirectStruct:
                 return GetBlockLayoutInfo(binaryNode->getLeft(), rowMajorAlreadyAssigned, storage,
                                           rowMajor);
             default:
                 UNREACHABLE();
                 return;
         }
     }

     const TType &type = node->getType();
     ASSERT(type.getQualifier() == EvqBuffer);
     const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
     ASSERT(interfaceBlock);
     *storage = interfaceBlock->blockStorage();
     // If the block doesn't have an instance name, rowMajorAlreadyAssigned will be false. In
     // this situation, we still need to set rowMajor's value.
     if (!rowMajorAlreadyAssigned)
     {
         *rowMajor = type.getLayoutQualifier().matrixPacking == EmpRowMajor;
     }
 }

 // It's possible that the current type has lost the original layout information. So we should pass
 // the right layout information to GetBlockMemberInfoByType.
 const BlockMemberInfo GetBlockMemberInfoByType(const TType &type,
                                                TLayoutBlockStorage storage,
                                                bool rowMajor)
 {
     sh::Std140BlockEncoder std140Encoder;
     sh::Std430BlockEncoder std430Encoder;
     sh::HLSLBlockEncoder hlslEncoder(sh::HLSLBlockEncoder::ENCODE_PACKED, false);
     sh::BlockLayoutEncoder *encoder = nullptr;

     if (storage == EbsStd140)
     {
         encoder = &std140Encoder;
     }
     else if (storage == EbsStd430)
     {
         encoder = &std430Encoder;
     }
     else
     {
         encoder = &hlslEncoder;
     }

     std::vector<unsigned int> arraySizes;
     const TSpan<const unsigned int> &typeArraySizes = type.getArraySizes();
     if (!typeArraySizes.empty())
     {
         arraySizes.assign(typeArraySizes.begin(), typeArraySizes.end());
     }
     return encoder->encodeType(GLVariableType(type), arraySizes, rowMajor);
 }

 const TField *GetFieldMemberInShaderStorageBlock(const TInterfaceBlock *interfaceBlock,
                                                  const ImmutableString &variableName)
 {
     for (const TField *field : interfaceBlock->fields())
     {
         if (field->name() == variableName)
         {
             return field;
         }
     }
     return nullptr;
 }

 const InterfaceBlock *FindInterfaceBlock(const TInterfaceBlock *needle,
                                          const std::vector<InterfaceBlock> &haystack)
 {
     for (const InterfaceBlock &block : haystack)
     {
         if (strcmp(block.name.c_str(), needle->name().data()) == 0)
         {
             ASSERT(block.fields.size() == needle->fields().size());
             return &block;
         }
     }

     UNREACHABLE();
     return nullptr;
 }

 std::string StripArrayIndices(const std::string &nameIn)
 {
     std::string name = nameIn;
     size_t pos       = name.find('[');
     while (pos != std::string::npos)
     {
         size_t closePos = name.find(']', pos);
         ASSERT(closePos != std::string::npos);
         name.erase(pos, closePos - pos + 1);
         pos = name.find('[', pos);
     }
     ASSERT(name.find(']') == std::string::npos);
     return name;
 }

 // Does not include any array indices.
 void MapVariableToField(const ShaderVariable &variable,
                         const TField *field,
                         std::string currentName,
                         ShaderVarToFieldMap *shaderVarToFieldMap)
 {
     ASSERT((field->type()->getStruct() == nullptr) == variable.fields.empty());
     (*shaderVarToFieldMap)[currentName] = field;

     if (!variable.fields.empty())
     {
         const TStructure *subStruct = field->type()->getStruct();
         ASSERT(variable.fields.size() == subStruct->fields().size());

         for (size_t index = 0; index < variable.fields.size(); ++index)
         {
             const TField *subField            = subStruct->fields()[index];
             const ShaderVariable &subVariable = variable.fields[index];
             std::string subName               = currentName + "." + subVariable.name;
             MapVariableToField(subVariable, subField, subName, shaderVarToFieldMap);
         }
     }
 }

 class BlockInfoVisitor final : public BlockEncoderVisitor
 {
   public:
     BlockInfoVisitor(const std::string &prefix,
                      TLayoutBlockStorage storage,
                      const ShaderVarToFieldMap &shaderVarToFieldMap,
                      BlockMemberInfoMap *blockInfoOut)
         : BlockEncoderVisitor(prefix, "", getEncoder(storage)),
           mShaderVarToFieldMap(shaderVarToFieldMap),
           mBlockInfoOut(blockInfoOut),
           mHLSLEncoder(HLSLBlockEncoder::ENCODE_PACKED, false),
           mStorage(storage)
     {}

     BlockLayoutEncoder *getEncoder(TLayoutBlockStorage storage)
     {
         switch (storage)
         {
             case EbsStd140:
                 return &mStd140Encoder;
             case EbsStd430:
                 return &mStd430Encoder;
             default:
                 return &mHLSLEncoder;
         }
     }

     void enterStructAccess(const ShaderVariable &structVar, bool isRowMajor) override
     {
         BlockEncoderVisitor::enterStructAccess(structVar, isRowMajor);

         std::string variableName = StripArrayIndices(collapseNameStack());

         // Remove the trailing "."
         variableName.pop_back();

         BlockInfoVisitor childVisitor(variableName, mStorage, mShaderVarToFieldMap, mBlockInfoOut);
         childVisitor.getEncoder(mStorage)->enterAggregateType(structVar);
         TraverseShaderVariables(structVar.fields, isRowMajor, &childVisitor);
         childVisitor.getEncoder(mStorage)->exitAggregateType(structVar);

         int offset      = static_cast<int>(getEncoder(mStorage)->getCurrentOffset());
         int arrayStride = static_cast<int>(childVisitor.getEncoder(mStorage)->getCurrentOffset());

         auto iter = mShaderVarToFieldMap.find(variableName);
         if (iter == mShaderVarToFieldMap.end())
             return;

         const TField *structField = iter->second;
         if (mBlockInfoOut->count(structField) == 0)
         {
             mBlockInfoOut->emplace(structField, BlockMemberInfo(offset, arrayStride, -1, false));
         }
     }

     void encodeVariable(const ShaderVariable &variable,
                         const BlockMemberInfo &variableInfo,
                         const std::string &name,
                         const std::string &mappedName) override
     {
         auto iter = mShaderVarToFieldMap.find(StripArrayIndices(name));
         if (iter == mShaderVarToFieldMap.end())
             return;

         const TField *field = iter->second;
         if (mBlockInfoOut->count(field) == 0)
         {
             mBlockInfoOut->emplace(field, variableInfo);
         }
     }

   private:
     const ShaderVarToFieldMap &mShaderVarToFieldMap;
     BlockMemberInfoMap *mBlockInfoOut;
     Std140BlockEncoder mStd140Encoder;
     Std430BlockEncoder mStd430Encoder;
     HLSLBlockEncoder mHLSLEncoder;
     TLayoutBlockStorage mStorage;
 };

 void GetShaderStorageBlockMembersInfo(const TInterfaceBlock *interfaceBlock,
                                       const std::vector<InterfaceBlock> &shaderStorageBlocks,
                                       BlockMemberInfoMap *blockInfoOut)
 {
     // Find the sh::InterfaceBlock.
     const InterfaceBlock *block = FindInterfaceBlock(interfaceBlock, shaderStorageBlocks);
     ASSERT(block);

     // Map ShaderVariable to TField.
     ShaderVarToFieldMap shaderVarToFieldMap;
     for (size_t index = 0; index < block->fields.size(); ++index)
     {
         const TField *field            = interfaceBlock->fields()[index];
         const ShaderVariable &variable = block->fields[index];
         MapVariableToField(variable, field, variable.name, &shaderVarToFieldMap);
     }

     BlockInfoVisitor visitor("", interfaceBlock->blockStorage(), shaderVarToFieldMap, blockInfoOut);
     TraverseShaderVariables(block->fields, false, &visitor);
 }

 TIntermTyped *Mul(TIntermTyped *left, TIntermTyped *right)
 {
     return left && right ? new TIntermBinary(EOpMul, left, right) : nullptr;
 }

 TIntermTyped *Add(TIntermTyped *left, TIntermTyped *right)
 {
     return left ? right ? new TIntermBinary(EOpAdd, left, right) : left : right;
 }

 }  // anonymous namespace

 ShaderStorageBlockOutputHLSL::ShaderStorageBlockOutputHLSL(
     OutputHLSL *outputHLSL,
     ResourcesHLSL *resourcesHLSL,
     const std::vector<InterfaceBlock> &shaderStorageBlocks)
     : mOutputHLSL(outputHLSL),
       mResourcesHLSL(resourcesHLSL),
       mShaderStorageBlocks(shaderStorageBlocks)
 {
     mSSBOFunctionHLSL = new ShaderStorageBlockFunctionHLSL;
 }

 ShaderStorageBlockOutputHLSL::~ShaderStorageBlockOutputHLSL()
 {
     SafeDelete(mSSBOFunctionHLSL);
 }

 void ShaderStorageBlockOutputHLSL::outputStoreFunctionCallPrefix(TIntermTyped *node)
 {
     traverseSSBOAccess(node, SSBOMethod::STORE);
 }

 void ShaderStorageBlockOutputHLSL::outputLoadFunctionCall(TIntermTyped *node)
 {
     traverseSSBOAccess(node, SSBOMethod::LOAD);
     mOutputHLSL->getInfoSink() << ")";
 }

 void ShaderStorageBlockOutputHLSL::outputLengthFunctionCall(TIntermTyped *node)
 {
     traverseSSBOAccess(node, SSBOMethod::LENGTH);
     mOutputHLSL->getInfoSink() << ")";
 }

 void ShaderStorageBlockOutputHLSL::outputAtomicMemoryFunctionCallPrefix(TIntermTyped *node,
                                                                         TOperator op)
 {
     switch (op)
     {
         case EOpAtomicAdd:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_ADD);
             break;
         case EOpAtomicMin:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_MIN);
             break;
         case EOpAtomicMax:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_MAX);
             break;
         case EOpAtomicAnd:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_AND);
             break;
         case EOpAtomicOr:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_OR);
             break;
         case EOpAtomicXor:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_XOR);
             break;
         case EOpAtomicExchange:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_EXCHANGE);
             break;
         case EOpAtomicCompSwap:
             traverseSSBOAccess(node, SSBOMethod::ATOMIC_COMPSWAP);
             break;
         default:
             UNREACHABLE();
             break;
     }
 }

 // Note that we must calculate the matrix stride here instead of ShaderStorageBlockFunctionHLSL.
 // It's because that if the current node's type is a vector which comes from a matrix, we will
 // lose the matrix type info once we enter ShaderStorageBlockFunctionHLSL.
 int ShaderStorageBlockOutputHLSL::getMatrixStride(TIntermTyped *node,
                                                   TLayoutBlockStorage storage,
                                                   bool rowMajor,
                                                   bool *isRowMajorMatrix) const
 {
     if (node->getType().isMatrix())
     {
         *isRowMajorMatrix = rowMajor;
         return GetBlockMemberInfoByType(node->getType(), storage, rowMajor).matrixStride;
     }

     if (node->getType().isVector())
     {
         TIntermBinary *binaryNode = node->getAsBinaryNode();
         if (binaryNode)
         {
             return getMatrixStride(binaryNode->getLeft(), storage, rowMajor, isRowMajorMatrix);
         }
         else
         {
             TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
             if (swizzleNode)
             {
                 return getMatrixStride(swizzleNode->getOperand(), storage, rowMajor,
                                        isRowMajorMatrix);
             }
         }
     }
     return 0;
 }

 void ShaderStorageBlockOutputHLSL::collectShaderStorageBlocks(TIntermTyped *node)
 {
     TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
     if (swizzleNode)
     {
         return collectShaderStorageBlocks(swizzleNode->getOperand());
     }

     TIntermBinary *binaryNode = node->getAsBinaryNode();
     if (binaryNode)
     {
         switch (binaryNode->getOp())
         {
             case EOpIndexDirectInterfaceBlock:
             case EOpIndexIndirect:
             case EOpIndexDirect:
             case EOpIndexDirectStruct:
                 return collectShaderStorageBlocks(binaryNode->getLeft());
             default:
                 UNREACHABLE();
                 return;
         }
     }

     const TIntermSymbol *symbolNode = node->getAsSymbolNode();
     const TType &type               = symbolNode->getType();
     ASSERT(type.getQualifier() == EvqBuffer);
     const TVariable &variable = symbolNode->variable();

     const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
     ASSERT(interfaceBlock);
     if (mReferencedShaderStorageBlocks.count(interfaceBlock->uniqueId().get()) == 0)
     {
         const TVariable *instanceVariable = nullptr;
         if (type.isInterfaceBlock())
         {
             instanceVariable = &variable;
         }
         mReferencedShaderStorageBlocks[interfaceBlock->uniqueId().get()] =
             new TReferencedBlock(interfaceBlock, instanceVariable);
         GetShaderStorageBlockMembersInfo(interfaceBlock, mShaderStorageBlocks,
                                          &mBlockMemberInfoMap);
     }
 }

 void ShaderStorageBlockOutputHLSL::traverseSSBOAccess(TIntermTyped *node, SSBOMethod method)
 {
     // TODO: Merge collectShaderStorageBlocks and GetBlockLayoutInfo to simplify the code.
     collectShaderStorageBlocks(node);

     // Note that we don't have correct BlockMemberInfo from mBlockMemberInfoMap at the current
     // point. But we must use those information to generate the right function name. So here we have
     // to calculate them again.
     TLayoutBlockStorage storage;
     bool rowMajor;
     GetBlockLayoutInfo(node, false, &storage, &rowMajor);
     int unsizedArrayStride = 0;
     if (node->getType().isUnsizedArray())
     {
         // The unsized array member must be the last member of a shader storage block.
         TIntermBinary *binaryNode = node->getAsBinaryNode();
         if (binaryNode)
         {
             const TInterfaceBlock *interfaceBlock =
                 binaryNode->getLeft()->getType().getInterfaceBlock();
             ASSERT(interfaceBlock);
             const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
             const TField *field               = interfaceBlock->fields()[index->getIConst(0)];
             auto fieldInfoIter                = mBlockMemberInfoMap.find(field);
             ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
             unsizedArrayStride = fieldInfoIter->second.arrayStride;
         }
         else
         {
             const TIntermSymbol *symbolNode       = node->getAsSymbolNode();
             const TVariable &variable             = symbolNode->variable();
             const TInterfaceBlock *interfaceBlock = symbolNode->getType().getInterfaceBlock();
             ASSERT(interfaceBlock);
             const TField *field =
                 GetFieldMemberInShaderStorageBlock(interfaceBlock, variable.name());
             auto fieldInfoIter = mBlockMemberInfoMap.find(field);
             ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
             unsizedArrayStride = fieldInfoIter->second.arrayStride;
         }
     }
     bool isRowMajorMatrix = false;
     int matrixStride      = getMatrixStride(node, storage, rowMajor, &isRowMajorMatrix);

     const TString &functionName = mSSBOFunctionHLSL->registerShaderStorageBlockFunction(
         node->getType(), method, storage, isRowMajorMatrix, matrixStride, unsizedArrayStride,
         node->getAsSwizzleNode());
     TInfoSinkBase &out = mOutputHLSL->getInfoSink();
     out << functionName;
     out << "(";
     BlockMemberInfo blockMemberInfo;
     TIntermNode *loc = traverseNode(out, node, &blockMemberInfo);
     out << ", ";
     loc->traverse(mOutputHLSL);
 }

 void ShaderStorageBlockOutputHLSL::writeShaderStorageBlocksHeader(GLenum shaderType,
                                                                   TInfoSinkBase &out) const
 {
     if (mReferencedShaderStorageBlocks.empty())
     {
         return;
     }

     mResourcesHLSL->allocateShaderStorageBlockRegisters(mReferencedShaderStorageBlocks);
     out << "// Shader Storage Blocks\n\n";
     if (shaderType == GL_COMPUTE_SHADER)
     {
         out << mResourcesHLSL->shaderStorageBlocksHeader(mReferencedShaderStorageBlocks);
     }
     else
     {
         out << kShaderStorageDeclarationString << "\n";
     }
     mSSBOFunctionHLSL->shaderStorageBlockFunctionHeader(out);
 }

 TIntermTyped *ShaderStorageBlockOutputHLSL::traverseNode(TInfoSinkBase &out,
                                                          TIntermTyped *node,
                                                          BlockMemberInfo *blockMemberInfo)
 {
     if (TIntermSymbol *symbolNode = node->getAsSymbolNode())
     {
         const TVariable &variable = symbolNode->variable();
         const TType &type         = variable.getType();
         if (type.isInterfaceBlock())
         {
             out << DecorateVariableIfNeeded(variable);
         }
         else
         {
             const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
             out << Decorate(interfaceBlock->name());
             const TField *field =
                 GetFieldMemberInShaderStorageBlock(interfaceBlock, variable.name());
             return createFieldOffset(field, blockMemberInfo);
         }
     }
     else if (TIntermSwizzle *swizzleNode = node->getAsSwizzleNode())
     {
         return traverseNode(out, swizzleNode->getOperand(), blockMemberInfo);
     }
     else if (TIntermBinary *binaryNode = node->getAsBinaryNode())
     {
         switch (binaryNode->getOp())
         {
             case EOpIndexDirect:
             {
                 const TType &leftType = binaryNode->getLeft()->getType();
                 if (leftType.isInterfaceBlock())
                 {
                     ASSERT(leftType.getQualifier() == EvqBuffer);
                     TIntermSymbol *instanceArraySymbol = binaryNode->getLeft()->getAsSymbolNode();

                     const int arrayIndex =
                         binaryNode->getRight()->getAsConstantUnion()->getIConst(0);
                     out << mResourcesHLSL->InterfaceBlockInstanceString(
                         instanceArraySymbol->getName(), arrayIndex);
                 }
                 else
                 {
                     return writeEOpIndexDirectOrIndirectOutput(out, binaryNode, blockMemberInfo);
                 }
                 break;
             }
             case EOpIndexIndirect:
             {
                 // We do not currently support indirect references to interface blocks
                 ASSERT(binaryNode->getLeft()->getBasicType() != EbtInterfaceBlock);
                 return writeEOpIndexDirectOrIndirectOutput(out, binaryNode, blockMemberInfo);
             }
             case EOpIndexDirectStruct:
             {
                 // We do not currently support direct references to interface blocks
                 ASSERT(binaryNode->getLeft()->getBasicType() != EbtInterfaceBlock);
                 TIntermTyped *left = traverseNode(out, binaryNode->getLeft(), blockMemberInfo);
                 const TStructure *structure       = binaryNode->getLeft()->getType().getStruct();
                 const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
                 const TField *field               = structure->fields()[index->getIConst(0)];
                 return Add(createFieldOffset(field, blockMemberInfo), left);
             }
             case EOpIndexDirectInterfaceBlock:
             {
                 ASSERT(IsInShaderStorageBlock(binaryNode->getLeft()));
                 traverseNode(out, binaryNode->getLeft(), blockMemberInfo);
                 const TInterfaceBlock *interfaceBlock =
                     binaryNode->getLeft()->getType().getInterfaceBlock();
                 const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
                 const TField *field               = interfaceBlock->fields()[index->getIConst(0)];
                 return createFieldOffset(field, blockMemberInfo);
             }
             default:
                 return nullptr;
         }
     }
     return nullptr;
 }

 TIntermTyped *ShaderStorageBlockOutputHLSL::writeEOpIndexDirectOrIndirectOutput(
     TInfoSinkBase &out,
     TIntermBinary *node,
     BlockMemberInfo *blockMemberInfo)
 {
     ASSERT(IsInShaderStorageBlock(node->getLeft()));
     TIntermTyped *left  = traverseNode(out, node->getLeft(), blockMemberInfo);
     TIntermTyped *right = node->getRight()->deepCopy();
     const TType &type   = node->getLeft()->getType();
     TLayoutBlockStorage storage;
     bool rowMajor;
     GetBlockLayoutInfo(node, false, &storage, &rowMajor);

     if (type.isArray())
     {
         const TSpan<const unsigned int> &arraySizes = type.getArraySizes();
         for (unsigned int i = 0; i < arraySizes.size() - 1; i++)
         {
             right = Mul(CreateUIntNode(arraySizes[i]), right);
         }
         right = Mul(CreateUIntNode(blockMemberInfo->arrayStride), right);
     }
     else if (type.isMatrix())
     {
         if (rowMajor)
         {
             right = Mul(CreateUIntNode(BlockLayoutEncoder::kBytesPerComponent), right);
         }
         else
         {
             right = Mul(CreateUIntNode(blockMemberInfo->matrixStride), right);
         }
     }
     else if (type.isVector())
     {
         if (blockMemberInfo->isRowMajorMatrix)
         {
             right = Mul(CreateUIntNode(blockMemberInfo->matrixStride), right);
         }
         else
         {
             right = Mul(CreateUIntNode(BlockLayoutEncoder::kBytesPerComponent), right);
         }
     }
     return Add(left, right);
 }

 TIntermTyped *ShaderStorageBlockOutputHLSL::createFieldOffset(const TField *field,
                                                               BlockMemberInfo *blockMemberInfo)
 {
     auto fieldInfoIter = mBlockMemberInfoMap.find(field);
     ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
     *blockMemberInfo = fieldInfoIter->second;
     return CreateUIntNode(blockMemberInfo->offset);
 }

 }  // namespace sh
	//
	// Copyright 2018 The ANGLE Project Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.
	//
	// ShaderStorageBlockOutputHLSL: A traverser to translate a ssbo_access_chain to an offset of
	// RWByteAddressBuffer.
	// //EOpIndexDirectInterfaceBlock
	// ssbo_variable :=
	// \| the name of the SSBO
	// \| the name of a variable in an SSBO backed interface block

	// // EOpIndexInDirect
	// // EOpIndexDirect
	// ssbo_array_indexing := ssbo_access_chain[expr_no_ssbo]

	// // EOpIndexDirectStruct
	// ssbo_structure_access := ssbo_access_chain.identifier

	// ssbo_access_chain :=
	// \| ssbo_variable
	// \| ssbo_array_indexing
	// \| ssbo_structure_access
	//

	#include "compiler/translator/ShaderStorageBlockOutputHLSL.h"

	#include "compiler/translator/ResourcesHLSL.h"
	#include "compiler/translator/blocklayoutHLSL.h"
	#include "compiler/translator/tree_util/IntermNode_util.h"
	#include "compiler/translator/util.h"

	namespace sh
	{

	namespace
	{

	constexpr const char kShaderStorageDeclarationString[] =
	"// @@ SHADER STORAGE DECLARATION STRING @@";

	void GetBlockLayoutInfo(TIntermTyped *node,
	bool rowMajorAlreadyAssigned,
	TLayoutBlockStorage *storage,
	bool *rowMajor)
	{
	TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
	if (swizzleNode)
	{
	return GetBlockLayoutInfo(swizzleNode->getOperand(), rowMajorAlreadyAssigned, storage,
	rowMajor);
	}

	TIntermBinary *binaryNode = node->getAsBinaryNode();
	if (binaryNode)
	{
	switch (binaryNode->getOp())
	{
	case EOpIndexDirectInterfaceBlock:
	{
	// The column_major/row_major qualifier of a field member overrides the interface
	// block's row_major/column_major. So we can assign rowMajor here and don't need to
	// assign it again. But we still need to call recursively to get the storage's
	// value.
	const TType &type = node->getType();
	*rowMajor = type.getLayoutQualifier().matrixPacking == EmpRowMajor;
	return GetBlockLayoutInfo(binaryNode->getLeft(), true, storage, rowMajor);
	}
	case EOpIndexIndirect:
	case EOpIndexDirect:
	case EOpIndexDirectStruct:
	return GetBlockLayoutInfo(binaryNode->getLeft(), rowMajorAlreadyAssigned, storage,
	rowMajor);
	default:
	UNREACHABLE();
	return;
	}
	}

	const TType &type = node->getType();
	ASSERT(type.getQualifier() == EvqBuffer);
	const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
	ASSERT(interfaceBlock);
	*storage = interfaceBlock->blockStorage();
	// If the block doesn't have an instance name, rowMajorAlreadyAssigned will be false. In
	// this situation, we still need to set rowMajor's value.
	if (!rowMajorAlreadyAssigned)
	{
	*rowMajor = type.getLayoutQualifier().matrixPacking == EmpRowMajor;
	}
	}

	// It's possible that the current type has lost the original layout information. So we should pass
	// the right layout information to GetBlockMemberInfoByType.
	const BlockMemberInfo GetBlockMemberInfoByType(const TType &type,
	TLayoutBlockStorage storage,
	bool rowMajor)
	{
	sh::Std140BlockEncoder std140Encoder;
	sh::Std430BlockEncoder std430Encoder;
	sh::HLSLBlockEncoder hlslEncoder(sh::HLSLBlockEncoder::ENCODE_PACKED, false);
	sh::BlockLayoutEncoder *encoder = nullptr;

	if (storage == EbsStd140)
	{
	encoder = &std140Encoder;
	}
	else if (storage == EbsStd430)
	{
	encoder = &std430Encoder;
	}
	else
	{
	encoder = &hlslEncoder;
	}

	std::vector<unsigned int> arraySizes;
	const TSpan<const unsigned int> &typeArraySizes = type.getArraySizes();
	if (!typeArraySizes.empty())
	{
	arraySizes.assign(typeArraySizes.begin(), typeArraySizes.end());
	}
	return encoder->encodeType(GLVariableType(type), arraySizes, rowMajor);
	}

	const TField GetFieldMemberInShaderStorageBlock(const TInterfaceBlock interfaceBlock,
	const ImmutableString &variableName)
	{
	for (const TField *field : interfaceBlock->fields())
	{
	if (field->name() == variableName)
	{
	return field;
	}
	}
	return nullptr;
	}

	const InterfaceBlock FindInterfaceBlock(const TInterfaceBlock needle,
	const std::vector<InterfaceBlock> &haystack)
	{
	for (const InterfaceBlock &block : haystack)
	{
	if (strcmp(block.name.c_str(), needle->name().data()) == 0)
	{
	ASSERT(block.fields.size() == needle->fields().size());
	return &block;
	}
	}

	UNREACHABLE();
	return nullptr;
	}

	std::string StripArrayIndices(const std::string &nameIn)
	{
	std::string name = nameIn;
	size_t pos = name.find('[');
	while (pos != std::string::npos)
	{
	size_t closePos = name.find(']', pos);
	ASSERT(closePos != std::string::npos);
	name.erase(pos, closePos - pos + 1);
	pos = name.find('[', pos);
	}
	ASSERT(name.find(']') == std::string::npos);
	return name;
	}

	// Does not include any array indices.
	void MapVariableToField(const ShaderVariable &variable,
	const TField *field,
	std::string currentName,
	ShaderVarToFieldMap *shaderVarToFieldMap)
	{
	ASSERT((field->type()->getStruct() == nullptr) == variable.fields.empty());
	(*shaderVarToFieldMap)[currentName] = field;

	if (!variable.fields.empty())
	{
	const TStructure *subStruct = field->type()->getStruct();
	ASSERT(variable.fields.size() == subStruct->fields().size());

	for (size_t index = 0; index < variable.fields.size(); ++index)
	{
	const TField *subField = subStruct->fields()[index];
	const ShaderVariable &subVariable = variable.fields[index];
	std::string subName = currentName + "." + subVariable.name;
	MapVariableToField(subVariable, subField, subName, shaderVarToFieldMap);
	}
	}
	}

	class BlockInfoVisitor final : public BlockEncoderVisitor
	{
	public:
	BlockInfoVisitor(const std::string &prefix,
	TLayoutBlockStorage storage,
	const ShaderVarToFieldMap &shaderVarToFieldMap,
	BlockMemberInfoMap *blockInfoOut)
	: BlockEncoderVisitor(prefix, "", getEncoder(storage)),
	mShaderVarToFieldMap(shaderVarToFieldMap),
	mBlockInfoOut(blockInfoOut),
	mHLSLEncoder(HLSLBlockEncoder::ENCODE_PACKED, false),
	mStorage(storage)
	{}

	BlockLayoutEncoder *getEncoder(TLayoutBlockStorage storage)
	{
	switch (storage)
	{
	case EbsStd140:
	return &mStd140Encoder;
	case EbsStd430:
	return &mStd430Encoder;
	default:
	return &mHLSLEncoder;
	}
	}

	void enterStructAccess(const ShaderVariable &structVar, bool isRowMajor) override
	{
	BlockEncoderVisitor::enterStructAccess(structVar, isRowMajor);

	std::string variableName = StripArrayIndices(collapseNameStack());

	// Remove the trailing "."
	variableName.pop_back();

	BlockInfoVisitor childVisitor(variableName, mStorage, mShaderVarToFieldMap, mBlockInfoOut);
	childVisitor.getEncoder(mStorage)->enterAggregateType(structVar);
	TraverseShaderVariables(structVar.fields, isRowMajor, &childVisitor);
	childVisitor.getEncoder(mStorage)->exitAggregateType(structVar);

	int offset = static_cast<int>(getEncoder(mStorage)->getCurrentOffset());
	int arrayStride = static_cast<int>(childVisitor.getEncoder(mStorage)->getCurrentOffset());

	auto iter = mShaderVarToFieldMap.find(variableName);
	if (iter == mShaderVarToFieldMap.end())
	return;

	const TField *structField = iter->second;
	if (mBlockInfoOut->count(structField) == 0)
	{
	mBlockInfoOut->emplace(structField, BlockMemberInfo(offset, arrayStride, -1, false));
	}
	}

	void encodeVariable(const ShaderVariable &variable,
	const BlockMemberInfo &variableInfo,
	const std::string &name,
	const std::string &mappedName) override
	{
	auto iter = mShaderVarToFieldMap.find(StripArrayIndices(name));
	if (iter == mShaderVarToFieldMap.end())
	return;

	const TField *field = iter->second;
	if (mBlockInfoOut->count(field) == 0)
	{
	mBlockInfoOut->emplace(field, variableInfo);
	}
	}

	private:
	const ShaderVarToFieldMap &mShaderVarToFieldMap;
	BlockMemberInfoMap *mBlockInfoOut;
	Std140BlockEncoder mStd140Encoder;
	Std430BlockEncoder mStd430Encoder;
	HLSLBlockEncoder mHLSLEncoder;
	TLayoutBlockStorage mStorage;
	};

	void GetShaderStorageBlockMembersInfo(const TInterfaceBlock *interfaceBlock,
	const std::vector<InterfaceBlock> &shaderStorageBlocks,
	BlockMemberInfoMap *blockInfoOut)
	{
	// Find the sh::InterfaceBlock.
	const InterfaceBlock *block = FindInterfaceBlock(interfaceBlock, shaderStorageBlocks);
	ASSERT(block);

	// Map ShaderVariable to TField.
	ShaderVarToFieldMap shaderVarToFieldMap;
	for (size_t index = 0; index < block->fields.size(); ++index)
	{
	const TField *field = interfaceBlock->fields()[index];
	const ShaderVariable &variable = block->fields[index];
	MapVariableToField(variable, field, variable.name, &shaderVarToFieldMap);
	}

	BlockInfoVisitor visitor("", interfaceBlock->blockStorage(), shaderVarToFieldMap, blockInfoOut);
	TraverseShaderVariables(block->fields, false, &visitor);
	}

	TIntermTyped Mul(TIntermTyped left, TIntermTyped *right)
	{
	return left && right ? new TIntermBinary(EOpMul, left, right) : nullptr;
	}

	TIntermTyped Add(TIntermTyped left, TIntermTyped *right)
	{
	return left ? right ? new TIntermBinary(EOpAdd, left, right) : left : right;
	}

	} // anonymous namespace

	ShaderStorageBlockOutputHLSL::ShaderStorageBlockOutputHLSL(
	OutputHLSL *outputHLSL,
	ResourcesHLSL *resourcesHLSL,
	const std::vector<InterfaceBlock> &shaderStorageBlocks)
	: mOutputHLSL(outputHLSL),
	mResourcesHLSL(resourcesHLSL),
	mShaderStorageBlocks(shaderStorageBlocks)
	{
	mSSBOFunctionHLSL = new ShaderStorageBlockFunctionHLSL;
	}

	ShaderStorageBlockOutputHLSL::~ShaderStorageBlockOutputHLSL()
	{
	SafeDelete(mSSBOFunctionHLSL);
	}

	void ShaderStorageBlockOutputHLSL::outputStoreFunctionCallPrefix(TIntermTyped *node)
	{
	traverseSSBOAccess(node, SSBOMethod::STORE);
	}

	void ShaderStorageBlockOutputHLSL::outputLoadFunctionCall(TIntermTyped *node)
	{
	traverseSSBOAccess(node, SSBOMethod::LOAD);
	mOutputHLSL->getInfoSink() << ")";
	}

	void ShaderStorageBlockOutputHLSL::outputLengthFunctionCall(TIntermTyped *node)
	{
	traverseSSBOAccess(node, SSBOMethod::LENGTH);
	mOutputHLSL->getInfoSink() << ")";
	}

	void ShaderStorageBlockOutputHLSL::outputAtomicMemoryFunctionCallPrefix(TIntermTyped *node,
	TOperator op)
	{
	switch (op)
	{
	case EOpAtomicAdd:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_ADD);
	break;
	case EOpAtomicMin:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_MIN);
	break;
	case EOpAtomicMax:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_MAX);
	break;
	case EOpAtomicAnd:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_AND);
	break;
	case EOpAtomicOr:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_OR);
	break;
	case EOpAtomicXor:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_XOR);
	break;
	case EOpAtomicExchange:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_EXCHANGE);
	break;
	case EOpAtomicCompSwap:
	traverseSSBOAccess(node, SSBOMethod::ATOMIC_COMPSWAP);
	break;
	default:
	UNREACHABLE();
	break;
	}
	}

	// Note that we must calculate the matrix stride here instead of ShaderStorageBlockFunctionHLSL.
	// It's because that if the current node's type is a vector which comes from a matrix, we will
	// lose the matrix type info once we enter ShaderStorageBlockFunctionHLSL.
	int ShaderStorageBlockOutputHLSL::getMatrixStride(TIntermTyped *node,
	TLayoutBlockStorage storage,
	bool rowMajor,
	bool *isRowMajorMatrix) const
	{
	if (node->getType().isMatrix())
	{
	*isRowMajorMatrix = rowMajor;
	return GetBlockMemberInfoByType(node->getType(), storage, rowMajor).matrixStride;
	}

	if (node->getType().isVector())
	{
	TIntermBinary *binaryNode = node->getAsBinaryNode();
	if (binaryNode)
	{
	return getMatrixStride(binaryNode->getLeft(), storage, rowMajor, isRowMajorMatrix);
	}
	else
	{
	TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
	if (swizzleNode)
	{
	return getMatrixStride(swizzleNode->getOperand(), storage, rowMajor,
	isRowMajorMatrix);
	}
	}
	}
	return 0;
	}

	void ShaderStorageBlockOutputHLSL::collectShaderStorageBlocks(TIntermTyped *node)
	{
	TIntermSwizzle *swizzleNode = node->getAsSwizzleNode();
	if (swizzleNode)
	{
	return collectShaderStorageBlocks(swizzleNode->getOperand());
	}

	TIntermBinary *binaryNode = node->getAsBinaryNode();
	if (binaryNode)
	{
	switch (binaryNode->getOp())
	{
	case EOpIndexDirectInterfaceBlock:
	case EOpIndexIndirect:
	case EOpIndexDirect:
	case EOpIndexDirectStruct:
	return collectShaderStorageBlocks(binaryNode->getLeft());
	default:
	UNREACHABLE();
	return;
	}
	}

	const TIntermSymbol *symbolNode = node->getAsSymbolNode();
	const TType &type = symbolNode->getType();
	ASSERT(type.getQualifier() == EvqBuffer);
	const TVariable &variable = symbolNode->variable();

	const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
	ASSERT(interfaceBlock);
	if (mReferencedShaderStorageBlocks.count(interfaceBlock->uniqueId().get()) == 0)
	{
	const TVariable *instanceVariable = nullptr;
	if (type.isInterfaceBlock())
	{
	instanceVariable = &variable;
	}
	mReferencedShaderStorageBlocks[interfaceBlock->uniqueId().get()] =
	new TReferencedBlock(interfaceBlock, instanceVariable);
	GetShaderStorageBlockMembersInfo(interfaceBlock, mShaderStorageBlocks,
	&mBlockMemberInfoMap);
	}
	}

	void ShaderStorageBlockOutputHLSL::traverseSSBOAccess(TIntermTyped *node, SSBOMethod method)
	{
	// TODO: Merge collectShaderStorageBlocks and GetBlockLayoutInfo to simplify the code.
	collectShaderStorageBlocks(node);

	// Note that we don't have correct BlockMemberInfo from mBlockMemberInfoMap at the current
	// point. But we must use those information to generate the right function name. So here we have
	// to calculate them again.
	TLayoutBlockStorage storage;
	bool rowMajor;
	GetBlockLayoutInfo(node, false, &storage, &rowMajor);
	int unsizedArrayStride = 0;
	if (node->getType().isUnsizedArray())
	{
	// The unsized array member must be the last member of a shader storage block.
	TIntermBinary *binaryNode = node->getAsBinaryNode();
	if (binaryNode)
	{
	const TInterfaceBlock *interfaceBlock =
	binaryNode->getLeft()->getType().getInterfaceBlock();
	ASSERT(interfaceBlock);
	const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
	const TField *field = interfaceBlock->fields()[index->getIConst(0)];
	auto fieldInfoIter = mBlockMemberInfoMap.find(field);
	ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
	unsizedArrayStride = fieldInfoIter->second.arrayStride;
	}
	else
	{
	const TIntermSymbol *symbolNode = node->getAsSymbolNode();
	const TVariable &variable = symbolNode->variable();
	const TInterfaceBlock *interfaceBlock = symbolNode->getType().getInterfaceBlock();
	ASSERT(interfaceBlock);
	const TField *field =
	GetFieldMemberInShaderStorageBlock(interfaceBlock, variable.name());
	auto fieldInfoIter = mBlockMemberInfoMap.find(field);
	ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
	unsizedArrayStride = fieldInfoIter->second.arrayStride;
	}
	}
	bool isRowMajorMatrix = false;
	int matrixStride = getMatrixStride(node, storage, rowMajor, &isRowMajorMatrix);

	const TString &functionName = mSSBOFunctionHLSL->registerShaderStorageBlockFunction(
	node->getType(), method, storage, isRowMajorMatrix, matrixStride, unsizedArrayStride,
	node->getAsSwizzleNode());
	TInfoSinkBase &out = mOutputHLSL->getInfoSink();
	out << functionName;
	out << "(";
	BlockMemberInfo blockMemberInfo;
	TIntermNode *loc = traverseNode(out, node, &blockMemberInfo);
	out << ", ";
	loc->traverse(mOutputHLSL);
	}

	void ShaderStorageBlockOutputHLSL::writeShaderStorageBlocksHeader(GLenum shaderType,
	TInfoSinkBase &out) const
	{
	if (mReferencedShaderStorageBlocks.empty())
	{
	return;
	}

	mResourcesHLSL->allocateShaderStorageBlockRegisters(mReferencedShaderStorageBlocks);
	out << "// Shader Storage Blocks\n\n";
	if (shaderType == GL_COMPUTE_SHADER)
	{
	out << mResourcesHLSL->shaderStorageBlocksHeader(mReferencedShaderStorageBlocks);
	}
	else
	{
	out << kShaderStorageDeclarationString << "\n";
	}
	mSSBOFunctionHLSL->shaderStorageBlockFunctionHeader(out);
	}

	TIntermTyped *ShaderStorageBlockOutputHLSL::traverseNode(TInfoSinkBase &out,
	TIntermTyped *node,
	BlockMemberInfo *blockMemberInfo)
	{
	if (TIntermSymbol *symbolNode = node->getAsSymbolNode())
	{
	const TVariable &variable = symbolNode->variable();
	const TType &type = variable.getType();
	if (type.isInterfaceBlock())
	{
	out << DecorateVariableIfNeeded(variable);
	}
	else
	{
	const TInterfaceBlock *interfaceBlock = type.getInterfaceBlock();
	out << Decorate(interfaceBlock->name());
	const TField *field =
	GetFieldMemberInShaderStorageBlock(interfaceBlock, variable.name());
	return createFieldOffset(field, blockMemberInfo);
	}
	}
	else if (TIntermSwizzle *swizzleNode = node->getAsSwizzleNode())
	{
	return traverseNode(out, swizzleNode->getOperand(), blockMemberInfo);
	}
	else if (TIntermBinary *binaryNode = node->getAsBinaryNode())
	{
	switch (binaryNode->getOp())
	{
	case EOpIndexDirect:
	{
	const TType &leftType = binaryNode->getLeft()->getType();
	if (leftType.isInterfaceBlock())
	{
	ASSERT(leftType.getQualifier() == EvqBuffer);
	TIntermSymbol *instanceArraySymbol = binaryNode->getLeft()->getAsSymbolNode();

	const int arrayIndex =
	binaryNode->getRight()->getAsConstantUnion()->getIConst(0);
	out << mResourcesHLSL->InterfaceBlockInstanceString(
	instanceArraySymbol->getName(), arrayIndex);
	}
	else
	{
	return writeEOpIndexDirectOrIndirectOutput(out, binaryNode, blockMemberInfo);
	}
	break;
	}
	case EOpIndexIndirect:
	{
	// We do not currently support indirect references to interface blocks
	ASSERT(binaryNode->getLeft()->getBasicType() != EbtInterfaceBlock);
	return writeEOpIndexDirectOrIndirectOutput(out, binaryNode, blockMemberInfo);
	}
	case EOpIndexDirectStruct:
	{
	// We do not currently support direct references to interface blocks
	ASSERT(binaryNode->getLeft()->getBasicType() != EbtInterfaceBlock);
	TIntermTyped *left = traverseNode(out, binaryNode->getLeft(), blockMemberInfo);
	const TStructure *structure = binaryNode->getLeft()->getType().getStruct();
	const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
	const TField *field = structure->fields()[index->getIConst(0)];
	return Add(createFieldOffset(field, blockMemberInfo), left);
	}
	case EOpIndexDirectInterfaceBlock:
	{
	ASSERT(IsInShaderStorageBlock(binaryNode->getLeft()));
	traverseNode(out, binaryNode->getLeft(), blockMemberInfo);
	const TInterfaceBlock *interfaceBlock =
	binaryNode->getLeft()->getType().getInterfaceBlock();
	const TIntermConstantUnion *index = binaryNode->getRight()->getAsConstantUnion();
	const TField *field = interfaceBlock->fields()[index->getIConst(0)];
	return createFieldOffset(field, blockMemberInfo);
	}
	default:
	return nullptr;
	}
	}
	return nullptr;
	}

	TIntermTyped *ShaderStorageBlockOutputHLSL::writeEOpIndexDirectOrIndirectOutput(
	TInfoSinkBase &out,
	TIntermBinary *node,
	BlockMemberInfo *blockMemberInfo)
	{
	ASSERT(IsInShaderStorageBlock(node->getLeft()));
	TIntermTyped *left = traverseNode(out, node->getLeft(), blockMemberInfo);
	TIntermTyped *right = node->getRight()->deepCopy();
	const TType &type = node->getLeft()->getType();
	TLayoutBlockStorage storage;
	bool rowMajor;
	GetBlockLayoutInfo(node, false, &storage, &rowMajor);

	if (type.isArray())
	{
	const TSpan<const unsigned int> &arraySizes = type.getArraySizes();
	for (unsigned int i = 0; i < arraySizes.size() - 1; i++)
	{
	right = Mul(CreateUIntNode(arraySizes[i]), right);
	}
	right = Mul(CreateUIntNode(blockMemberInfo->arrayStride), right);
	}
	else if (type.isMatrix())
	{
	if (rowMajor)
	{
	right = Mul(CreateUIntNode(BlockLayoutEncoder::kBytesPerComponent), right);
	}
	else
	{
	right = Mul(CreateUIntNode(blockMemberInfo->matrixStride), right);
	}
	}
	else if (type.isVector())
	{
	if (blockMemberInfo->isRowMajorMatrix)
	{
	right = Mul(CreateUIntNode(blockMemberInfo->matrixStride), right);
	}
	else
	{
	right = Mul(CreateUIntNode(BlockLayoutEncoder::kBytesPerComponent), right);
	}
	}
	return Add(left, right);
	}

	TIntermTyped ShaderStorageBlockOutputHLSL::createFieldOffset(const TField field,
	BlockMemberInfo *blockMemberInfo)
	{
	auto fieldInfoIter = mBlockMemberInfoMap.find(field);
	ASSERT(fieldInfoIter != mBlockMemberInfoMap.end());
	*blockMemberInfo = fieldInfoIter->second;
	return CreateUIntNode(blockMemberInfo->offset);
	}

	} // namespace sh