summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorjsmall-nvidia <jsmall@nvidia.com>2019-06-04 15:10:26 -0400
committerGitHub <noreply@github.com>2019-06-04 15:10:26 -0400
commit0d9071bd1511ee2cb7d6ba6ce9e250d25613ddca (patch)
tree410558e5bae917d027209f5807f8633db8291069
parent0a8f7ae6b899718150f359a378e53bfedd090090 (diff)
Review improvements on #971: WIP: Support for other source target languages (#974)
* * Added SourceStyle to CLikeSourceEmitter, to limit cases to actual target types. * Made Impl methods _ prefixed * Small tidyup * * SourceStream -> SourceWriter * use slang-emit- prefix on SourceWriter file * * Remove EmitContext -> merge into CLikeSourceEmitter * slang-c-like-source-emitter -> slang-emit-source.cpp * ExtensionUsageTracker -> GLSLExtensionTracker slang-extension-usage-tracker.cpp/.h -> slang-emit-glsl-extension-tracker.cpp/.h * emit-source.cpp.h -> emit-c-like.cpp/.h * Small fix to move where some _ prefixed functions are declared in CLikeSourceEmitter.
Diffstat
-rw-r--r--source/slang/slang-emit-c-like.cpp (renamed from source/slang/slang-c-like-source-emitter.cpp)1439
-rw-r--r--source/slang/slang-emit-c-like.h (renamed from source/slang/slang-c-like-source-emitter.h)152
-rw-r--r--source/slang/slang-emit-context.cpp7
-rw-r--r--source/slang/slang-emit-context.h79
-rw-r--r--source/slang/slang-emit-glsl-extension-tracker.cpp44
-rw-r--r--source/slang/slang-emit-glsl-extension-tracker.h34
-rw-r--r--source/slang/slang-emit-source-writer.cpp (renamed from source/slang/slang-source-stream.cpp)56
-rw-r--r--source/slang/slang-emit-source-writer.h (renamed from source/slang/slang-source-stream.h)8
-rw-r--r--source/slang/slang-emit.cpp44
-rw-r--r--source/slang/slang-extension-usage-tracker.cpp44
-rw-r--r--source/slang/slang-extension-usage-tracker.h34
-rw-r--r--source/slang/slang-ir-glsl-legalize.cpp12
-rw-r--r--source/slang/slang-ir-glsl-legalize.h4
-rw-r--r--source/slang/slang.vcxproj14
-rw-r--r--source/slang/slang.vcxproj.filters32
15 files changed, 1019 insertions, 984 deletions
diff --git a/source/slang/slang-c-like-source-emitter.cpp b/source/slang/slang-emit-c-like.cpp
index dacb5e9b5..67bf891a4 100644
--- a/source/slang/slang-c-like-source-emitter.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -1,5 +1,5 @@
-// slang-c-like-source-emitter.cpp
-#include "slang-c-like-source-emitter.h"
+// slang-emit-c-like.cpp
+#include "slang-emit-c-like.h"
#include "../core/slang-writer.h"
#include "slang-ir-bind-existentials.h"
@@ -22,8 +22,7 @@
#include "slang-type-layout.h"
#include "slang-visitor.h"
-#include "slang-source-stream.h"
-#include "slang-emit-context.h"
+#include "slang-emit-source-writer.h"
#include "slang-mangled-lexer.h"
#include <assert.h>
@@ -100,10 +99,63 @@ struct CLikeSourceEmitter::ComputeEmitActionsContext
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!! CLikeSourceEmitter !!!!!!!!!!!!!!!!!!!!!!!!!! */
-CLikeSourceEmitter::CLikeSourceEmitter(EmitContext* context)
- : m_context(context),
- m_stream(context->stream)
-{}
+/* static */CLikeSourceEmitter::SourceStyle CLikeSourceEmitter::getSourceStyle(CodeGenTarget target)
+{
+ switch (target)
+ {
+ default:
+ case CodeGenTarget::Unknown:
+ case CodeGenTarget::None:
+ {
+ return SourceStyle::Unknown;
+ }
+ case CodeGenTarget::GLSL:
+ case CodeGenTarget::GLSL_Vulkan:
+ case CodeGenTarget::GLSL_Vulkan_OneDesc:
+ {
+ return SourceStyle::GLSL;
+ }
+ case CodeGenTarget::HLSL:
+ {
+ return SourceStyle::HLSL;
+ }
+ case CodeGenTarget::SPIRV:
+ case CodeGenTarget::SPIRVAssembly:
+ case CodeGenTarget::DXBytecode:
+ case CodeGenTarget::DXBytecodeAssembly:
+ case CodeGenTarget::DXIL:
+ case CodeGenTarget::DXILAssembly:
+ {
+ return SourceStyle::Unknown;
+ }
+ case CodeGenTarget::CSource:
+ {
+ return SourceStyle::C;
+ }
+ case CodeGenTarget::CPPSource:
+ {
+ return SourceStyle::CPP;
+ }
+ }
+}
+
+CLikeSourceEmitter::CLikeSourceEmitter(const CInfo& cinfo)
+{
+ m_writer = cinfo.sourceWriter;
+ m_sourceStyle = getSourceStyle(cinfo.target);
+ SLANG_ASSERT(m_sourceStyle != SourceStyle::Unknown);
+
+ m_target = cinfo.target;
+
+ m_compileRequest = cinfo.compileRequest;
+ m_entryPoint = cinfo.entryPoint;
+ m_effectiveProfile = cinfo.effectiveProfile;
+
+ m_entryPointLayout = cinfo.entryPointLayout;
+
+ m_programLayout = cinfo.programLayout;
+ m_globalStructLayout = cinfo.globalStructLayout;
+}
//
// Types
@@ -113,27 +165,27 @@ void CLikeSourceEmitter::emitDeclarator(EDeclarator* declarator)
{
if (!declarator) return;
- m_stream->emit(" ");
+ m_writer->emit(" ");
switch (declarator->flavor)
{
case EDeclarator::Flavor::name:
- m_stream->emitName(declarator->name, declarator->loc);
+ m_writer->emitName(declarator->name, declarator->loc);
break;
case EDeclarator::Flavor::Array:
emitDeclarator(declarator->next);
- m_stream->emit("[");
+ m_writer->emit("[");
if(auto elementCount = declarator->elementCount)
{
emitVal(elementCount, getInfo(EmitOp::General));
}
- m_stream->emit("]");
+ m_writer->emit("]");
break;
case EDeclarator::Flavor::UnsizedArray:
emitDeclarator(declarator->next);
- m_stream->emit("[]");
+ m_writer->emit("[]");
break;
default:
@@ -150,17 +202,17 @@ void CLikeSourceEmitter::emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa
// no prefix
break;
- case kIROp_Int8Type: m_stream->emit("i8"); break;
- case kIROp_Int16Type: m_stream->emit("i16"); break;
- case kIROp_IntType: m_stream->emit("i"); break;
- case kIROp_Int64Type: m_stream->emit("i64"); break;
+ case kIROp_Int8Type: m_writer->emit("i8"); break;
+ case kIROp_Int16Type: m_writer->emit("i16"); break;
+ case kIROp_IntType: m_writer->emit("i"); break;
+ case kIROp_Int64Type: m_writer->emit("i64"); break;
- case kIROp_UInt8Type: m_stream->emit("u8"); break;
- case kIROp_UInt16Type: m_stream->emit("u16"); break;
- case kIROp_UIntType: m_stream->emit("u"); break;
- case kIROp_UInt64Type: m_stream->emit("u64"); break;
+ case kIROp_UInt8Type: m_writer->emit("u8"); break;
+ case kIROp_UInt16Type: m_writer->emit("u16"); break;
+ case kIROp_UIntType: m_writer->emit("u"); break;
+ case kIROp_UInt64Type: m_writer->emit("u64"); break;
- case kIROp_BoolType: m_stream->emit("b"); break;
+ case kIROp_BoolType: m_writer->emit("b"); break;
case kIROp_HalfType:
{
@@ -171,11 +223,11 @@ void CLikeSourceEmitter::emitGLSLTypePrefix(IRType* type, bool promoteHalfToFloa
}
else
{
- m_stream->emit("f16");
+ m_writer->emit("f16");
}
break;
}
- case kIROp_DoubleType: m_stream->emit("d"); break;
+ case kIROp_DoubleType: m_writer->emit("d"); break;
case kIROp_VectorType:
emitGLSLTypePrefix(cast<IRVectorType>(type)->getElementType(), promoteHalfToFloat);
@@ -199,19 +251,19 @@ void CLikeSourceEmitter::emitHLSLTextureType(IRTextureTypeBase* texType)
break;
case SLANG_RESOURCE_ACCESS_READ_WRITE:
- m_stream->emit("RW");
+ m_writer->emit("RW");
break;
case SLANG_RESOURCE_ACCESS_RASTER_ORDERED:
- m_stream->emit("RasterizerOrdered");
+ m_writer->emit("RasterizerOrdered");
break;
case SLANG_RESOURCE_ACCESS_APPEND:
- m_stream->emit("Append");
+ m_writer->emit("Append");
break;
case SLANG_RESOURCE_ACCESS_CONSUME:
- m_stream->emit("Consume");
+ m_writer->emit("Consume");
break;
default:
@@ -221,11 +273,11 @@ void CLikeSourceEmitter::emitHLSLTextureType(IRTextureTypeBase* texType)
switch (texType->GetBaseShape())
{
- case TextureFlavor::Shape::Shape1D: m_stream->emit("Texture1D"); break;
- case TextureFlavor::Shape::Shape2D: m_stream->emit("Texture2D"); break;
- case TextureFlavor::Shape::Shape3D: m_stream->emit("Texture3D"); break;
- case TextureFlavor::Shape::ShapeCube: m_stream->emit("TextureCube"); break;
- case TextureFlavor::Shape::ShapeBuffer: m_stream->emit("Buffer"); break;
+ case TextureFlavor::Shape::Shape1D: m_writer->emit("Texture1D"); break;
+ case TextureFlavor::Shape::Shape2D: m_writer->emit("Texture2D"); break;
+ case TextureFlavor::Shape::Shape3D: m_writer->emit("Texture3D"); break;
+ case TextureFlavor::Shape::ShapeCube: m_writer->emit("TextureCube"); break;
+ case TextureFlavor::Shape::ShapeBuffer: m_writer->emit("Buffer"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape");
break;
@@ -233,15 +285,15 @@ void CLikeSourceEmitter::emitHLSLTextureType(IRTextureTypeBase* texType)
if (texType->isMultisample())
{
- m_stream->emit("MS");
+ m_writer->emit("MS");
}
if (texType->isArray())
{
- m_stream->emit("Array");
+ m_writer->emit("Array");
}
- m_stream->emit("<");
+ m_writer->emit("<");
emitType(texType->getElementType());
- m_stream->emit(" >");
+ m_writer->emit(" >");
}
void CLikeSourceEmitter::emitGLSLTextureOrTextureSamplerType(IRTextureTypeBase* type, char const* baseName)
@@ -256,14 +308,14 @@ void CLikeSourceEmitter::emitGLSLTextureOrTextureSamplerType(IRTextureTypeBase*
emitGLSLTypePrefix(type->getElementType(), true);
}
- m_stream->emit(baseName);
+ m_writer->emit(baseName);
switch (type->GetBaseShape())
{
- case TextureFlavor::Shape::Shape1D: m_stream->emit("1D"); break;
- case TextureFlavor::Shape::Shape2D: m_stream->emit("2D"); break;
- case TextureFlavor::Shape::Shape3D: m_stream->emit("3D"); break;
- case TextureFlavor::Shape::ShapeCube: m_stream->emit("Cube"); break;
- case TextureFlavor::Shape::ShapeBuffer: m_stream->emit("Buffer"); break;
+ case TextureFlavor::Shape::Shape1D: m_writer->emit("1D"); break;
+ case TextureFlavor::Shape::Shape2D: m_writer->emit("2D"); break;
+ case TextureFlavor::Shape::Shape3D: m_writer->emit("3D"); break;
+ case TextureFlavor::Shape::ShapeCube: m_writer->emit("Cube"); break;
+ case TextureFlavor::Shape::ShapeBuffer: m_writer->emit("Buffer"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled resource shape");
break;
@@ -271,11 +323,11 @@ void CLikeSourceEmitter::emitGLSLTextureOrTextureSamplerType(IRTextureTypeBase*
if (type->isMultisample())
{
- m_stream->emit("MS");
+ m_writer->emit("MS");
}
if (type->isArray())
{
- m_stream->emit("Array");
+ m_writer->emit("Array");
}
}
@@ -307,13 +359,13 @@ void CLikeSourceEmitter::emitGLSLImageType(IRGLSLImageType* type)
void CLikeSourceEmitter::emitTextureType(IRTextureType* texType)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
emitHLSLTextureType(texType);
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
emitGLSLTextureType(texType);
break;
@@ -325,9 +377,9 @@ void CLikeSourceEmitter::emitTextureType(IRTextureType* texType)
void CLikeSourceEmitter::emitTextureSamplerType(IRTextureSamplerType* type)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
emitGLSLTextureSamplerType(type);
break;
@@ -339,13 +391,13 @@ void CLikeSourceEmitter::emitTextureSamplerType(IRTextureSamplerType* type)
void CLikeSourceEmitter::emitImageType(IRGLSLImageType* type)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
emitHLSLTextureType(type);
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
emitGLSLImageType(type);
break;
@@ -428,73 +480,71 @@ static UnownedStringSlice _getCTypeName(IROp op)
void CLikeSourceEmitter::_emitCVecType(IROp op, Int size)
{
- m_stream->emit("Vec");
+ m_writer->emit("Vec");
const UnownedStringSlice postFix = _getCTypeVecPostFix(_getCType(op));
- m_stream->emit(postFix);
+ m_writer->emit(postFix);
if (postFix.size() > 1)
{
- m_stream->emit("_");
+ m_writer->emit("_");
}
- m_stream->emit(size);
+ m_writer->emit(size);
}
void CLikeSourceEmitter::_emitCMatType(IROp op, IRIntegerValue rowCount, IRIntegerValue colCount)
{
- m_stream->emit("Mat");
+ m_writer->emit("Mat");
const UnownedStringSlice postFix = _getCTypeVecPostFix(_getCType(op));
- m_stream->emit(postFix);
+ m_writer->emit(postFix);
if (postFix.size() > 1)
{
- m_stream->emit("_");
+ m_writer->emit("_");
}
- m_stream->emit(rowCount);
- m_stream->emit(colCount);
+ m_writer->emit(rowCount);
+ m_writer->emit(colCount);
}
void CLikeSourceEmitter::_emitCFunc(BuiltInCOp cop, IRType* type)
{
- emitSimpleTypeImpl(type);
- m_stream->emit("_");
+ _emitSimpleType(type);
+ m_writer->emit("_");
switch (cop)
{
- case BuiltInCOp::Init: m_stream->emit("init");
- case BuiltInCOp::Splat: m_stream->emit("splat"); break;
+ case BuiltInCOp::Init: m_writer->emit("init");
+ case BuiltInCOp::Splat: m_writer->emit("splat"); break;
}
}
void CLikeSourceEmitter::emitVectorTypeName(IRType* elementType, IRIntegerValue elementCount)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::GLSL:
- case CodeGenTarget::GLSL_Vulkan:
- case CodeGenTarget::GLSL_Vulkan_OneDesc:
+ case SourceStyle::GLSL:
{
if (elementCount > 1)
{
emitGLSLTypePrefix(elementType);
- m_stream->emit("vec");
- m_stream->emit(elementCount);
+ m_writer->emit("vec");
+ m_writer->emit(elementCount);
}
else
{
- emitSimpleTypeImpl(elementType);
+ _emitSimpleType(elementType);
}
}
break;
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
// TODO(tfoley): should really emit these with sugar
- m_stream->emit("vector<");
+ m_writer->emit("vector<");
emitType(elementType);
- m_stream->emit(",");
- m_stream->emit(elementCount);
- m_stream->emit(">");
+ m_writer->emit(",");
+ m_writer->emit(elementCount);
+ m_writer->emit(">");
break;
- case CodeGenTarget::CSource:
- case CodeGenTarget::CPPSource:
+ case SourceStyle::C:
+ case SourceStyle::CPP:
_emitCVecType(elementType->op, Int(elementCount));
break;
@@ -504,7 +554,7 @@ void CLikeSourceEmitter::emitVectorTypeName(IRType* elementType, IRIntegerValue
}
}
-void CLikeSourceEmitter::emitVectorTypeImpl(IRVectorType* vecType)
+void CLikeSourceEmitter::_emitVectorType(IRVectorType* vecType)
{
IRInst* elementCountInst = vecType->getElementCount();
if (elementCountInst->op != kIROp_IntLit)
@@ -526,37 +576,35 @@ void CLikeSourceEmitter::emitVectorTypeImpl(IRVectorType* vecType)
emitVectorTypeName(elementType, elementCount);
}
-void CLikeSourceEmitter::emitMatrixTypeImpl(IRMatrixType* matType)
+void CLikeSourceEmitter::_emitMatrixType(IRMatrixType* matType)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::GLSL:
- case CodeGenTarget::GLSL_Vulkan:
- case CodeGenTarget::GLSL_Vulkan_OneDesc:
+ case SourceStyle::GLSL:
{
emitGLSLTypePrefix(matType->getElementType());
- m_stream->emit("mat");
+ m_writer->emit("mat");
emitVal(matType->getRowCount(), getInfo(EmitOp::General));
// TODO(tfoley): only emit the next bit
// for non-square matrix
- m_stream->emit("x");
+ m_writer->emit("x");
emitVal(matType->getColumnCount(), getInfo(EmitOp::General));
}
break;
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
// TODO(tfoley): should really emit these with sugar
- m_stream->emit("matrix<");
+ m_writer->emit("matrix<");
emitType(matType->getElementType());
- m_stream->emit(",");
+ m_writer->emit(",");
emitVal(matType->getRowCount(), getInfo(EmitOp::General));
- m_stream->emit(",");
+ m_writer->emit(",");
emitVal(matType->getColumnCount(), getInfo(EmitOp::General));
- m_stream->emit("> ");
+ m_writer->emit("> ");
break;
- case CodeGenTarget::CPPSource:
- case CodeGenTarget::CSource:
+ case SourceStyle::CPP:
+ case SourceStyle::C:
{
const auto rowCount = static_cast<const IRConstant*>(matType->getRowCount())->value.intVal;
const auto colCount = static_cast<const IRConstant*>(matType->getColumnCount())->value.intVal;
@@ -573,25 +621,25 @@ void CLikeSourceEmitter::emitMatrixTypeImpl(IRMatrixType* matType)
void CLikeSourceEmitter::emitSamplerStateType(IRSamplerStateTypeBase* samplerStateType)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
default:
switch (samplerStateType->op)
{
- case kIROp_SamplerStateType: m_stream->emit("SamplerState"); break;
- case kIROp_SamplerComparisonStateType: m_stream->emit("SamplerComparisonState"); break;
+ case kIROp_SamplerStateType: m_writer->emit("SamplerState"); break;
+ case kIROp_SamplerComparisonStateType: m_writer->emit("SamplerComparisonState"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled sampler state flavor");
break;
}
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
switch (samplerStateType->op)
{
- case kIROp_SamplerStateType: m_stream->emit("sampler"); break;
- case kIROp_SamplerComparisonStateType: m_stream->emit("samplerShadow"); break;
+ case kIROp_SamplerStateType: m_writer->emit("sampler"); break;
+ case kIROp_SamplerComparisonStateType: m_writer->emit("samplerShadow"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled sampler state flavor");
break;
@@ -603,31 +651,31 @@ void CLikeSourceEmitter::emitSamplerStateType(IRSamplerStateTypeBase* samplerSta
void CLikeSourceEmitter::emitStructuredBufferType(IRHLSLStructuredBufferTypeBase* type)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
default:
{
switch (type->op)
{
- case kIROp_HLSLStructuredBufferType: m_stream->emit("StructuredBuffer"); break;
- case kIROp_HLSLRWStructuredBufferType: m_stream->emit("RWStructuredBuffer"); break;
- case kIROp_HLSLRasterizerOrderedStructuredBufferType: m_stream->emit("RasterizerOrderedStructuredBuffer"); break;
- case kIROp_HLSLAppendStructuredBufferType: m_stream->emit("AppendStructuredBuffer"); break;
- case kIROp_HLSLConsumeStructuredBufferType: m_stream->emit("ConsumeStructuredBuffer"); break;
+ case kIROp_HLSLStructuredBufferType: m_writer->emit("StructuredBuffer"); break;
+ case kIROp_HLSLRWStructuredBufferType: m_writer->emit("RWStructuredBuffer"); break;
+ case kIROp_HLSLRasterizerOrderedStructuredBufferType: m_writer->emit("RasterizerOrderedStructuredBuffer"); break;
+ case kIROp_HLSLAppendStructuredBufferType: m_writer->emit("AppendStructuredBuffer"); break;
+ case kIROp_HLSLConsumeStructuredBufferType: m_writer->emit("ConsumeStructuredBuffer"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled structured buffer type");
break;
}
- m_stream->emit("<");
+ m_writer->emit("<");
emitType(type->getElementType());
- m_stream->emit(" >");
+ m_writer->emit(" >");
}
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
// TODO: We desugar global variables with structured-buffer type into GLSL
// `buffer` declarations, but we don't currently handle structured-buffer types
// in other contexts (e.g., as function parameters). The simplest thing to do
@@ -642,17 +690,17 @@ void CLikeSourceEmitter::emitStructuredBufferType(IRHLSLStructuredBufferTypeBase
void CLikeSourceEmitter::emitUntypedBufferType(IRUntypedBufferResourceType* type)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
default:
{
switch (type->op)
{
- case kIROp_HLSLByteAddressBufferType: m_stream->emit("ByteAddressBuffer"); break;
- case kIROp_HLSLRWByteAddressBufferType: m_stream->emit("RWByteAddressBuffer"); break;
- case kIROp_HLSLRasterizerOrderedByteAddressBufferType: m_stream->emit("RasterizerOrderedByteAddressBuffer"); break;
- case kIROp_RaytracingAccelerationStructureType: m_stream->emit("RaytracingAccelerationStructure"); break;
+ case kIROp_HLSLByteAddressBufferType: m_writer->emit("ByteAddressBuffer"); break;
+ case kIROp_HLSLRWByteAddressBufferType: m_writer->emit("RWByteAddressBuffer"); break;
+ case kIROp_HLSLRasterizerOrderedByteAddressBufferType: m_writer->emit("RasterizerOrderedByteAddressBuffer"); break;
+ case kIROp_RaytracingAccelerationStructureType: m_writer->emit("RaytracingAccelerationStructure"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type");
@@ -661,19 +709,19 @@ void CLikeSourceEmitter::emitUntypedBufferType(IRUntypedBufferResourceType* type
}
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
{
switch (type->op)
{
case kIROp_RaytracingAccelerationStructureType:
requireGLSLExtension("GL_NV_ray_tracing");
- m_stream->emit("accelerationStructureNV");
+ m_writer->emit("accelerationStructureNV");
break;
// TODO: These "translations" are obviously wrong for GLSL.
- case kIROp_HLSLByteAddressBufferType: m_stream->emit("ByteAddressBuffer"); break;
- case kIROp_HLSLRWByteAddressBufferType: m_stream->emit("RWByteAddressBuffer"); break;
- case kIROp_HLSLRasterizerOrderedByteAddressBufferType: m_stream->emit("RasterizerOrderedByteAddressBuffer"); break;
+ case kIROp_HLSLByteAddressBufferType: m_writer->emit("ByteAddressBuffer"); break;
+ case kIROp_HLSLRWByteAddressBufferType: m_writer->emit("RWByteAddressBuffer"); break;
+ case kIROp_HLSLRasterizerOrderedByteAddressBufferType: m_writer->emit("RasterizerOrderedByteAddressBuffer"); break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled buffer type");
@@ -686,54 +734,54 @@ void CLikeSourceEmitter::emitUntypedBufferType(IRUntypedBufferResourceType* type
void CLikeSourceEmitter::_requireHalf()
{
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
- m_context->extensionUsageTracker.requireGLSLHalfExtension();
+ m_glslExtensionTracker.requireHalfExtension();
}
}
-void CLikeSourceEmitter::emitSimpleTypeImpl(IRType* type)
+void CLikeSourceEmitter::_emitSimpleType(IRType* type)
{
switch (type->op)
{
default:
break;
- case kIROp_VoidType: m_stream->emit("void"); return;
- case kIROp_BoolType: m_stream->emit("bool"); return;
+ case kIROp_VoidType: m_writer->emit("void"); return;
+ case kIROp_BoolType: m_writer->emit("bool"); return;
- case kIROp_Int8Type: m_stream->emit("int8_t"); return;
- case kIROp_Int16Type: m_stream->emit("int16_t"); return;
- case kIROp_IntType: m_stream->emit("int"); return;
- case kIROp_Int64Type: m_stream->emit("int64_t"); return;
+ case kIROp_Int8Type: m_writer->emit("int8_t"); return;
+ case kIROp_Int16Type: m_writer->emit("int16_t"); return;
+ case kIROp_IntType: m_writer->emit("int"); return;
+ case kIROp_Int64Type: m_writer->emit("int64_t"); return;
- case kIROp_UInt8Type: m_stream->emit("uint8_t"); return;
- case kIROp_UInt16Type: m_stream->emit("uint16_t"); return;
- case kIROp_UIntType: m_stream->emit("uint"); return;
- case kIROp_UInt64Type: m_stream->emit("uint64_t"); return;
+ case kIROp_UInt8Type: m_writer->emit("uint8_t"); return;
+ case kIROp_UInt16Type: m_writer->emit("uint16_t"); return;
+ case kIROp_UIntType: m_writer->emit("uint"); return;
+ case kIROp_UInt64Type: m_writer->emit("uint64_t"); return;
case kIROp_HalfType:
{
_requireHalf();
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
- m_stream->emit("float16_t");
+ m_writer->emit("float16_t");
}
else
{
- m_stream->emit("half");
+ m_writer->emit("half");
}
return;
}
- case kIROp_FloatType: m_stream->emit("float"); return;
- case kIROp_DoubleType: m_stream->emit("double"); return;
+ case kIROp_FloatType: m_writer->emit("float"); return;
+ case kIROp_DoubleType: m_writer->emit("double"); return;
case kIROp_VectorType:
- emitVectorTypeImpl((IRVectorType*)type);
+ _emitVectorType((IRVectorType*)type);
return;
case kIROp_MatrixType:
- emitMatrixTypeImpl((IRMatrixType*)type);
+ _emitMatrixType((IRMatrixType*)type);
return;
case kIROp_SamplerStateType:
@@ -742,7 +790,7 @@ void CLikeSourceEmitter::emitSimpleTypeImpl(IRType* type)
return;
case kIROp_StructType:
- m_stream->emit(getIRName(type));
+ m_writer->emit(getIRName(type));
return;
}
@@ -778,20 +826,20 @@ void CLikeSourceEmitter::emitSimpleTypeImpl(IRType* type)
// HACK: As a fallback for HLSL targets, assume that the name of the
// instruction being used is the same as the name of the HLSL type.
- if(m_context->target == CodeGenTarget::HLSL)
+ if(getSourceStyle() == SourceStyle::HLSL)
{
auto opInfo = getIROpInfo(type->op);
- m_stream->emit(opInfo.name);
+ m_writer->emit(opInfo.name);
UInt operandCount = type->getOperandCount();
if(operandCount)
{
- m_stream->emit("<");
+ m_writer->emit("<");
for(UInt ii = 0; ii < operandCount; ++ii)
{
- if(ii != 0) m_stream->emit(", ");
+ if(ii != 0) m_writer->emit(", ");
emitVal(type->getOperand(ii), getInfo(EmitOp::General));
}
- m_stream->emit(" >");
+ m_writer->emit(" >");
}
return;
@@ -800,47 +848,47 @@ void CLikeSourceEmitter::emitSimpleTypeImpl(IRType* type)
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled type");
}
-void CLikeSourceEmitter::emitArrayTypeImpl(IRArrayType* arrayType, EDeclarator* declarator)
+void CLikeSourceEmitter::_emitArrayType(IRArrayType* arrayType, EDeclarator* declarator)
{
EDeclarator arrayDeclarator;
arrayDeclarator.flavor = EDeclarator::Flavor::Array;
arrayDeclarator.next = declarator;
arrayDeclarator.elementCount = arrayType->getElementCount();
- emitTypeImpl(arrayType->getElementType(), &arrayDeclarator);
+ _emitType(arrayType->getElementType(), &arrayDeclarator);
}
-void CLikeSourceEmitter::emitUnsizedArrayTypeImpl(IRUnsizedArrayType* arrayType, EDeclarator* declarator)
+void CLikeSourceEmitter::_emitUnsizedArrayType(IRUnsizedArrayType* arrayType, EDeclarator* declarator)
{
EDeclarator arrayDeclarator;
arrayDeclarator.flavor = EDeclarator::Flavor::UnsizedArray;
arrayDeclarator.next = declarator;
- emitTypeImpl(arrayType->getElementType(), &arrayDeclarator);
+ _emitType(arrayType->getElementType(), &arrayDeclarator);
}
-void CLikeSourceEmitter::emitTypeImpl(IRType* type, EDeclarator* declarator)
+void CLikeSourceEmitter::_emitType(IRType* type, EDeclarator* declarator)
{
switch (type->op)
{
default:
- emitSimpleTypeImpl(type);
+ _emitSimpleType(type);
emitDeclarator(declarator);
break;
case kIROp_RateQualifiedType:
{
auto rateQualifiedType = cast<IRRateQualifiedType>(type);
- emitTypeImpl(rateQualifiedType->getValueType(), declarator);
+ _emitType(rateQualifiedType->getValueType(), declarator);
}
break;
case kIROp_ArrayType:
- emitArrayTypeImpl(cast<IRArrayType>(type), declarator);
+ _emitArrayType(cast<IRArrayType>(type), declarator);
break;
case kIROp_UnsizedArrayType:
- emitUnsizedArrayTypeImpl(cast<IRUnsizedArrayType>(type), declarator);
+ _emitUnsizedArrayType(cast<IRUnsizedArrayType>(type), declarator);
break;
}
@@ -852,13 +900,13 @@ void CLikeSourceEmitter::emitType(
Name* name,
SourceLoc const& nameLoc)
{
- m_stream->advanceToSourceLocation(typeLoc);
+ m_writer->advanceToSourceLocation(typeLoc);
EDeclarator nameDeclarator;
nameDeclarator.flavor = EDeclarator::Flavor::name;
nameDeclarator.name = name;
nameDeclarator.loc = nameLoc;
- emitTypeImpl(type, &nameDeclarator);
+ _emitType(type, &nameDeclarator);
}
void CLikeSourceEmitter::emitType(IRType* type, Name* name)
@@ -879,7 +927,7 @@ void CLikeSourceEmitter::emitType(IRType* type, const String& name)
void CLikeSourceEmitter::emitType(IRType* type)
{
- emitTypeImpl(type, nullptr);
+ _emitType(type, nullptr);
}
//
@@ -893,7 +941,7 @@ bool CLikeSourceEmitter::maybeEmitParens(EmitOpInfo& outerPrec, EmitOpInfo prec)
if (needParens)
{
- m_stream->emit("(");
+ m_writer->emit("(");
outerPrec = getInfo(EmitOp::None);
}
@@ -902,21 +950,21 @@ bool CLikeSourceEmitter::maybeEmitParens(EmitOpInfo& outerPrec, EmitOpInfo prec)
void CLikeSourceEmitter::maybeCloseParens(bool needClose)
{
- if(needClose) m_stream->emit(")");
+ if(needClose) m_writer->emit(")");
}
bool CLikeSourceEmitter::isTargetIntrinsicModifierApplicable(const String& targetName)
{
- switch(m_context->target)
+ switch(getSourceStyle())
{
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled code generation target");
return false;
- case CodeGenTarget::CSource: return targetName == "c";
- case CodeGenTarget::CPPSource: return targetName == "cpp";
- case CodeGenTarget::GLSL: return targetName == "glsl";
- case CodeGenTarget::HLSL: return targetName == "hlsl";
+ case SourceStyle::C: return targetName == "c";
+ case SourceStyle::CPP: return targetName == "cpp";
+ case SourceStyle::GLSL: return targetName == "glsl";
+ case SourceStyle::HLSL: return targetName == "hlsl";
}
}
@@ -950,7 +998,7 @@ bool CLikeSourceEmitter::isTargetIntrinsicModifierApplicable(
void CLikeSourceEmitter::emitStringLiteral(
String const& value)
{
- m_stream->emit("\"");
+ m_writer->emit("\"");
for (auto c : value)
{
// TODO: This needs a more complete implementation,
@@ -960,31 +1008,31 @@ void CLikeSourceEmitter::emitStringLiteral(
switch (c)
{
default:
- m_stream->emit(buffer);
+ m_writer->emit(buffer);
break;
- case '\"': m_stream->emit("\\\"");
- case '\'': m_stream->emit("\\\'");
- case '\\': m_stream->emit("\\\\");
- case '\n': m_stream->emit("\\n");
- case '\r': m_stream->emit("\\r");
- case '\t': m_stream->emit("\\t");
+ case '\"': m_writer->emit("\\\"");
+ case '\'': m_writer->emit("\\\'");
+ case '\\': m_writer->emit("\\\\");
+ case '\n': m_writer->emit("\\n");
+ case '\r': m_writer->emit("\\r");
+ case '\t': m_writer->emit("\\t");
}
}
- m_stream->emit("\"");
+ m_writer->emit("\"");
}
void CLikeSourceEmitter::requireGLSLExtension(String const& name)
{
- m_context->extensionUsageTracker.requireGLSLExtension(name);
+ m_glslExtensionTracker.requireExtension(name);
}
void CLikeSourceEmitter::requireGLSLVersion(ProfileVersion version)
{
- if (m_context->target != CodeGenTarget::GLSL)
+ if (getSourceStyle() != SourceStyle::GLSL)
return;
- m_context->extensionUsageTracker.requireGLSLVersion(version);
+ m_glslExtensionTracker.requireVersion(version);
}
void CLikeSourceEmitter::requireGLSLVersion(int version)
@@ -1013,7 +1061,7 @@ void CLikeSourceEmitter::requireGLSLVersion(int version)
void CLikeSourceEmitter::setSampleRateFlag()
{
- m_context->entryPointLayout->flags |= EntryPointLayout::Flag::usesAnySampleRateInput;
+ m_entryPointLayout->flags |= EntryPointLayout::Flag::usesAnySampleRateInput;
}
void CLikeSourceEmitter::doSampleRateInputCheck(Name* name)
@@ -1090,9 +1138,9 @@ void CLikeSourceEmitter::emitHLSLRegisterSemantic(LayoutResourceKind kind, EmitV
// units, and then a "component" within that register, based on 4-byte
// offsets from there. We cannot support more fine-grained offsets than that.
- m_stream->emit(" : ");
- m_stream->emit(uniformSemanticSpelling);
- m_stream->emit("(c");
+ m_writer->emit(" : ");
+ m_writer->emit(uniformSemanticSpelling);
+ m_writer->emit("(c");
// Size of a logical `c` register in bytes
auto registerSize = 16;
@@ -1101,7 +1149,7 @@ void CLikeSourceEmitter::emitHLSLRegisterSemantic(LayoutResourceKind kind, EmitV
auto componentSize = 4;
size_t startRegister = offset / registerSize;
- m_stream->emit(int(startRegister));
+ m_writer->emit(int(startRegister));
size_t byteOffsetInRegister = offset % registerSize;
@@ -1116,10 +1164,10 @@ void CLikeSourceEmitter::emitHLSLRegisterSemantic(LayoutResourceKind kind, EmitV
size_t startComponent = byteOffsetInRegister / componentSize;
static const char* kComponentNames[] = {"x", "y", "z", "w"};
- m_stream->emit(".");
- m_stream->emit(kComponentNames[startComponent]);
+ m_writer->emit(".");
+ m_writer->emit(kComponentNames[startComponent]);
}
- m_stream->emit(")");
+ m_writer->emit(")");
}
break;
@@ -1131,32 +1179,32 @@ void CLikeSourceEmitter::emitHLSLRegisterSemantic(LayoutResourceKind kind, EmitV
break;
default:
{
- m_stream->emit(" : register(");
+ m_writer->emit(" : register(");
switch( kind )
{
case LayoutResourceKind::ConstantBuffer:
- m_stream->emit("b");
+ m_writer->emit("b");
break;
case LayoutResourceKind::ShaderResource:
- m_stream->emit("t");
+ m_writer->emit("t");
break;
case LayoutResourceKind::UnorderedAccess:
- m_stream->emit("u");
+ m_writer->emit("u");
break;
case LayoutResourceKind::SamplerState:
- m_stream->emit("s");
+ m_writer->emit("s");
break;
default:
SLANG_DIAGNOSE_UNEXPECTED(getSink(), SourceLoc(), "unhandled HLSL register type");
break;
}
- m_stream->emit(index);
+ m_writer->emit(index);
if(space)
{
- m_stream->emit(", space");
- m_stream->emit(space);
+ m_writer->emit(", space");
+ m_writer->emit(space);
}
- m_stream->emit(")");
+ m_writer->emit(")");
}
}
}
@@ -1167,12 +1215,12 @@ void CLikeSourceEmitter::emitHLSLRegisterSemantics(EmitVarChain* chain, char con
auto layout = chain->varLayout;
- switch( m_context->target )
+ switch( getSourceStyle())
{
default:
return;
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
break;
}
@@ -1245,24 +1293,24 @@ bool CLikeSourceEmitter::emitGLSLLayoutQualifier(LayoutResourceKind kind, EmitVa
{
requireGLSLExtension("GL_ARB_enhanced_layouts");
- m_stream->emit("layout(offset = ");
- m_stream->emit(index);
- m_stream->emit(")\n");
+ m_writer->emit("layout(offset = ");
+ m_writer->emit(index);
+ m_writer->emit(")\n");
}
}
break;
case LayoutResourceKind::VertexInput:
case LayoutResourceKind::FragmentOutput:
- m_stream->emit("layout(location = ");
- m_stream->emit(index);
- m_stream->emit(")\n");
+ m_writer->emit("layout(location = ");
+ m_writer->emit(index);
+ m_writer->emit(")\n");
break;
case LayoutResourceKind::SpecializationConstant:
- m_stream->emit("layout(constant_id = ");
- m_stream->emit(index);
- m_stream->emit(")\n");
+ m_writer->emit("layout(constant_id = ");
+ m_writer->emit(index);
+ m_writer->emit(")\n");
break;
case LayoutResourceKind::ConstantBuffer:
@@ -1270,21 +1318,21 @@ bool CLikeSourceEmitter::emitGLSLLayoutQualifier(LayoutResourceKind kind, EmitVa
case LayoutResourceKind::UnorderedAccess:
case LayoutResourceKind::SamplerState:
case LayoutResourceKind::DescriptorTableSlot:
- m_stream->emit("layout(binding = ");
- m_stream->emit(index);
+ m_writer->emit("layout(binding = ");
+ m_writer->emit(index);
if(space)
{
- m_stream->emit(", set = ");
- m_stream->emit(space);
+ m_writer->emit(", set = ");
+ m_writer->emit(space);
}
- m_stream->emit(")\n");
+ m_writer->emit(")\n");
break;
case LayoutResourceKind::PushConstantBuffer:
- m_stream->emit("layout(push_constant)\n");
+ m_writer->emit("layout(push_constant)\n");
break;
case LayoutResourceKind::ShaderRecord:
- m_stream->emit("layout(shaderRecordNV)\n");
+ m_writer->emit("layout(shaderRecordNV)\n");
break;
}
@@ -1295,12 +1343,12 @@ void CLikeSourceEmitter::emitGLSLLayoutQualifiers(RefPtr<VarLayout> layout, Emit
{
if(!layout) return;
- switch( getTarget())
+ switch( getSourceStyle())
{
default:
return;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
break;
}
@@ -1321,7 +1369,7 @@ void CLikeSourceEmitter::emitGLSLLayoutQualifiers(RefPtr<VarLayout> layout, Emit
void CLikeSourceEmitter::emitGLSLVersionDirective()
{
- auto effectiveProfile = m_context->effectiveProfile;
+ auto effectiveProfile = m_effectiveProfile;
if(effectiveProfile.getFamily() == ProfileFamily::GLSL)
{
requireGLSLVersion(effectiveProfile.GetVersion());
@@ -1336,13 +1384,13 @@ void CLikeSourceEmitter::emitGLSLVersionDirective()
//
// TODO: Either correctly compute a minimum required version, or require
// the user to specify a version as part of the target.
- m_context->extensionUsageTracker.requireGLSLVersion(ProfileVersion::GLSL_450);
+ m_glslExtensionTracker.requireVersion(ProfileVersion::GLSL_450);
- auto requiredProfileVersion = m_context->extensionUsageTracker.getRequiredGLSLProfileVersion();
+ auto requiredProfileVersion = m_glslExtensionTracker.getRequiredProfileVersion();
switch (requiredProfileVersion)
{
#define CASE(TAG, VALUE) \
- case ProfileVersion::TAG: m_stream->emit("#version " #VALUE "\n"); return
+ case ProfileVersion::TAG: m_writer->emit("#version " #VALUE "\n"); return
CASE(GLSL_110, 110);
CASE(GLSL_120, 120);
@@ -1371,18 +1419,18 @@ void CLikeSourceEmitter::emitGLSLVersionDirective()
//
// For now we just fall back to a reasonably recent version.
- m_stream->emit("#version 420\n");
+ m_writer->emit("#version 420\n");
}
void CLikeSourceEmitter::emitGLSLPreprocessorDirectives()
{
- switch(getTarget())
+ switch(getSourceStyle())
{
- // Don't emit this stuff unless we are targetting GLSL
+ // Don't emit this stuff unless we are targeting GLSL
default:
return;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
break;
}
@@ -1408,12 +1456,12 @@ void CLikeSourceEmitter::emitLayoutDirectives(TargetRequest* targetReq)
auto matrixLayoutMode = targetReq->getDefaultMatrixLayoutMode();
- switch(m_context->target)
+ switch(getSourceStyle())
{
default:
return;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
// Reminder: the meaning of row/column major layout
// in our semantics is the *opposite* of what GLSL
// calls them, because what they call "columns"
@@ -1423,27 +1471,27 @@ void CLikeSourceEmitter::emitLayoutDirectives(TargetRequest* targetReq)
{
case kMatrixLayoutMode_RowMajor:
default:
- m_stream->emit("layout(column_major) uniform;\n");
- m_stream->emit("layout(column_major) buffer;\n");
+ m_writer->emit("layout(column_major) uniform;\n");
+ m_writer->emit("layout(column_major) buffer;\n");
break;
case kMatrixLayoutMode_ColumnMajor:
- m_stream->emit("layout(row_major) uniform;\n");
- m_stream->emit("layout(row_major) buffer;\n");
+ m_writer->emit("layout(row_major) uniform;\n");
+ m_writer->emit("layout(row_major) buffer;\n");
break;
}
break;
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
switch(matrixLayoutMode)
{
case kMatrixLayoutMode_RowMajor:
default:
- m_stream->emit("#pragma pack_matrix(row_major)\n");
+ m_writer->emit("#pragma pack_matrix(row_major)\n");
break;
case kMatrixLayoutMode_ColumnMajor:
- m_stream->emit("#pragma pack_matrix(column_major)\n");
+ m_writer->emit("#pragma pack_matrix(column_major)\n");
break;
}
break;
@@ -1452,14 +1500,14 @@ void CLikeSourceEmitter::emitLayoutDirectives(TargetRequest* targetReq)
UInt CLikeSourceEmitter::allocateUniqueID()
{
- return m_context->uniqueIDCounter++;
+ return m_uniqueIDCounter++;
}
// IR-level emit logic
UInt CLikeSourceEmitter::getID(IRInst* value)
{
- auto& mapIRValueToID = m_context->mapIRValueToID;
+ auto& mapIRValueToID = m_mapIRValueToID;
UInt id = 0;
if (mapIRValueToID.TryGetValue(value, id))
@@ -1487,7 +1535,7 @@ String CLikeSourceEmitter::scrubName(const String& name)
// and write some legal characters to the output as we go.
StringBuilder sb;
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
// GLSL reserverse all names that start with `gl_`,
// so if we are in danger of collision, then make
@@ -1640,9 +1688,9 @@ String CLikeSourceEmitter::generateIRName(IRInst* inst)
String key = sb.ProduceString();
UInt count = 0;
- m_context->uniqueNameCounters.TryGetValue(key, count);
+ m_uniqueNameCounters.TryGetValue(key, count);
- m_context->uniqueNameCounters[key] = count+1;
+ m_uniqueNameCounters[key] = count+1;
sb.append(Int32(count));
return sb.ProduceString();
@@ -1666,10 +1714,10 @@ String CLikeSourceEmitter::generateIRName(IRInst* inst)
String CLikeSourceEmitter::getIRName(IRInst* inst)
{
String name;
- if(!m_context->mapInstToName.TryGetValue(inst, name))
+ if(!m_mapInstToName.TryGetValue(inst, name))
{
name = generateIRName(inst);
- m_context->mapInstToName.Add(inst, name);
+ m_mapInstToName.Add(inst, name);
}
return name;
}
@@ -1681,20 +1729,20 @@ void CLikeSourceEmitter::emitDeclarator(IRDeclaratorInfo* declarator)
switch( declarator->flavor )
{
case IRDeclaratorInfo::Flavor::Simple:
- m_stream->emit(" ");
- m_stream->emit(*declarator->name);
+ m_writer->emit(" ");
+ m_writer->emit(*declarator->name);
break;
case IRDeclaratorInfo::Flavor::Ptr:
- m_stream->emit("*");
+ m_writer->emit("*");
emitDeclarator(declarator->next);
break;
case IRDeclaratorInfo::Flavor::Array:
emitDeclarator(declarator->next);
- m_stream->emit("[");
+ m_writer->emit("[");
emitIROperand(declarator->elementCount, IREmitMode::Default, getInfo(EmitOp::General));
- m_stream->emit("]");
+ m_writer->emit("]");
break;
}
}
@@ -1704,17 +1752,17 @@ void CLikeSourceEmitter::emitIRSimpleValue(IRInst* inst)
switch(inst->op)
{
case kIROp_IntLit:
- m_stream->emit(((IRConstant*) inst)->value.intVal);
+ m_writer->emit(((IRConstant*) inst)->value.intVal);
break;
case kIROp_FloatLit:
- m_stream->emit(((IRConstant*) inst)->value.floatVal);
+ m_writer->emit(((IRConstant*) inst)->value.floatVal);
break;
case kIROp_BoolLit:
{
bool val = ((IRConstant*)inst)->value.intVal != 0;
- m_stream->emit(val ? "true" : "false");
+ m_writer->emit(val ? "true" : "false");
}
break;
@@ -1725,11 +1773,6 @@ void CLikeSourceEmitter::emitIRSimpleValue(IRInst* inst)
}
-CodeGenTarget CLikeSourceEmitter::getTarget()
-{
- return m_context->target;
-}
-
bool CLikeSourceEmitter::shouldFoldIRInstIntoUseSites(IRInst* inst, IREmitMode mode)
{
// Certain opcodes should never/always be folded in
@@ -1846,7 +1889,7 @@ bool CLikeSourceEmitter::shouldFoldIRInstIntoUseSites(IRInst* inst, IREmitMode m
// GLSL doesn't allow texture/resource types to
// be used as first-class values, so we need
// to fold them into their use sites in all cases
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
if(as<IRResourceTypeBase>(type))
{
@@ -1947,7 +1990,7 @@ void CLikeSourceEmitter::emitIROperand(IRInst* inst, IREmitMode mode, EmitOpInfo
{
case 0: // nothing yet
default:
- m_stream->emit(getIRName(inst));
+ m_writer->emit(getIRName(inst));
break;
}
}
@@ -1957,13 +2000,13 @@ void CLikeSourceEmitter::emitIRArgs(IRInst* inst, IREmitMode mode)
UInt argCount = inst->getOperandCount();
IRUse* args = inst->getOperands();
- m_stream->emit("(");
+ m_writer->emit("(");
for(UInt aa = 0; aa < argCount; ++aa)
{
- if(aa != 0) m_stream->emit(", ");
+ if(aa != 0) m_writer->emit(", ");
emitIROperand(args[aa].get(), mode, getInfo(EmitOp::General));
}
- m_stream->emit(")");
+ m_writer->emit(")");
}
void CLikeSourceEmitter::emitIRType(IRType* type, String const& name)
@@ -1987,10 +2030,10 @@ void CLikeSourceEmitter::emitIRRateQualifiers(IRRate* rate)
if(as<IRConstExprRate>(rate))
{
- switch( getTarget() )
+ switch( getSourceStyle() )
{
- case CodeGenTarget::GLSL:
- m_stream->emit("const ");
+ case SourceStyle::GLSL:
+ m_writer->emit("const ");
break;
default:
@@ -2000,14 +2043,14 @@ void CLikeSourceEmitter::emitIRRateQualifiers(IRRate* rate)
if (as<IRGroupSharedRate>(rate))
{
- switch( getTarget() )
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
- m_stream->emit("groupshared ");
+ case SourceStyle::HLSL:
+ m_writer->emit("groupshared ");
break;
- case CodeGenTarget::GLSL:
- m_stream->emit("shared ");
+ case SourceStyle::GLSL:
+ m_writer->emit("shared ");
break;
default:
@@ -2035,7 +2078,7 @@ void CLikeSourceEmitter::emitIRInstResultDecl(IRInst* inst)
emitIRRateQualifiers(inst);
emitIRType(type, getIRName(inst));
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
}
IRTargetIntrinsicDecoration* CLikeSourceEmitter::findTargetIntrinsicDecoration(IRInst* inst)
@@ -2094,14 +2137,14 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
auto prec = getInfo(EmitOp::Postfix);
bool needClose = maybeEmitParens(outerPrec, prec);
- m_stream->emit(name);
- m_stream->emit("(");
+ m_writer->emit(name);
+ m_writer->emit("(");
for (Index aa = 0; aa < argCount; ++aa)
{
- if (aa != 0) m_stream->emit(", ");
+ if (aa != 0) m_writer->emit(", ");
emitIROperand(args[aa].get(), mode, getInfo(EmitOp::General));
}
- m_stream->emit(")");
+ m_writer->emit(")");
maybeCloseParens(needClose);
return;
@@ -2115,7 +2158,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// If it returns void -> then we don't need parenthesis
if (as<IRVoidType>(returnType) == nullptr)
{
- m_stream->emit("(");
+ m_writer->emit("(");
openParenCount++;
}
@@ -2129,7 +2172,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
if( c != '$' )
{
// Not an escape sequence
- m_stream->emitRawTextSpan(&c, &c+1);
+ m_writer->emitRawTextSpan(&c, &c+1);
continue;
}
@@ -2145,9 +2188,9 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// Simple case: emit one of the direct arguments to the call
Index argIndex = d - '0';
SLANG_RELEASE_ASSERT((0 <= argIndex) && (argIndex < argCount));
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(args[argIndex].get(), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
break;
@@ -2169,15 +2212,15 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
{
if (as<IRSamplerComparisonStateType>(samplerType))
{
- m_stream->emit("Shadow");
+ m_writer->emit("Shadow");
}
}
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(textureArg, mode, getInfo(EmitOp::General));
- m_stream->emit(",");
+ m_writer->emit(",");
emitIROperand(samplerArg, mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
else
{
@@ -2212,8 +2255,8 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// We only need to output a cast if the underlying type is half.
if (underlyingType && underlyingType->op == kIROp_HalfType)
{
- emitSimpleTypeImpl(elementType);
- m_stream->emit("(");
+ _emitSimpleType(elementType);
+ m_writer->emit("(");
openParenCount++;
}
}
@@ -2235,7 +2278,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
if (auto basicType = as<IRBasicType>(elementType))
{
// A scalar result is expected
- m_stream->emit(".x");
+ m_writer->emit(".x");
}
else if (auto vectorType = as<IRVectorType>(elementType))
{
@@ -2245,7 +2288,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
if (elementCount < 4)
{
char const* swiz[] = { "", ".x", ".xy", ".xyz", "" };
- m_stream->emit(swiz[elementCount]);
+ m_writer->emit(swiz[elementCount]);
}
}
else
@@ -2273,7 +2316,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
if (auto vectorType = as<IRVectorType>(vectorArg->getDataType()))
{
auto elementCount = GetIntVal(vectorType->getElementCount());
- m_stream->emit(elementCount);
+ m_writer->emit(elementCount);
}
else
{
@@ -2314,22 +2357,22 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// needed.
//
emitVectorTypeName(elementType, 4);
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(arg, mode, getInfo(EmitOp::General));
for(IRIntegerValue ii = elementCount; ii < 4; ++ii)
{
- m_stream->emit(", ");
- if(getTarget() == CodeGenTarget::GLSL)
+ m_writer->emit(", ");
+ if(getSourceStyle() == SourceStyle::GLSL)
{
- emitSimpleTypeImpl(elementType);
- m_stream->emit("(0)");
+ _emitSimpleType(elementType);
+ m_writer->emit("(0)");
}
else
{
- m_stream->emit("0");
+ m_writer->emit("0");
}
}
- m_stream->emit(")");
+ m_writer->emit(")");
}
}
break;
@@ -2352,11 +2395,11 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
auto arg = args[argIndex].get();
if(arg->op == kIROp_ImageSubscript)
{
- m_stream->emit("imageA");
+ m_writer->emit("imageA");
}
else
{
- m_stream->emit("a");
+ m_writer->emit("a");
}
}
break;
@@ -2377,16 +2420,16 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
auto arg = args[argIndex].get();
if(arg->op == kIROp_ImageSubscript)
{
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
// TODO: we don't handle the multisample
// case correctly here, where the last
// component of the image coordinate needs
// to be broken out into its own argument.
//
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(arg->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit("), ");
+ m_writer->emit("), ");
// The coordinate argument will have been computed
// as a `vector<uint, N>` because that is how the
@@ -2411,30 +2454,30 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
if (elementCount > 1)
{
- m_stream->emit("ivec");
- m_stream->emit(elementCount);
+ m_writer->emit("ivec");
+ m_writer->emit(elementCount);
}
else
{
- m_stream->emit("int");
+ m_writer->emit("int");
}
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(arg->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
else
{
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(arg, mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
}
else
{
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(arg, mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
}
break;
@@ -2460,7 +2503,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
auto argLoad = as<IRLoad>(arg);
SLANG_RELEASE_ASSERT(argLoad);
auto argVar = argLoad->getOperand(0);
- m_stream->emit(getRayPayloadLocation(argVar));
+ m_writer->emit(getRayPayloadLocation(argVar));
}
break;
@@ -2477,7 +2520,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
auto argLoad = as<IRLoad>(arg);
SLANG_RELEASE_ASSERT(argLoad);
auto argVar = argLoad->getOperand(0);
- m_stream->emit(getCallablePayloadLocation(argVar));
+ m_writer->emit(getCallablePayloadLocation(argVar));
}
break;
@@ -2486,15 +2529,15 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// The `$XT` case handles selecting between
// the `gl_HitTNV` and `gl_RayTmaxNV` builtins,
// based on what stage we are using:
- switch( m_context->entryPoint->getStage() )
+ switch( m_entryPoint->getStage() )
{
default:
- m_stream->emit("gl_RayTmaxNV");
+ m_writer->emit("gl_RayTmaxNV");
break;
case Stage::AnyHit:
case Stage::ClosestHit:
- m_stream->emit("gl_HitTNV");
+ m_writer->emit("gl_HitTNV");
break;
}
}
@@ -2516,7 +2559,7 @@ void CLikeSourceEmitter::emitTargetIntrinsicCallExpr(
// Close any remaining open parens
for (; openParenCount > 0; --openParenCount)
{
- m_stream->emit(")");
+ m_writer->emit(")");
}
}
}
@@ -2607,13 +2650,13 @@ void CLikeSourceEmitter::emitIntrinsicCallExpr(
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(inst->getOperand(operandIndex++), mode, leftSide(outerPrec, prec));
- m_stream->emit("[");
+ m_writer->emit("[");
emitIROperand(inst->getOperand(operandIndex++), mode, getInfo(EmitOp::General));
- m_stream->emit("]");
+ m_writer->emit("]");
if(operandIndex < operandCount)
{
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
emitIROperand(inst->getOperand(operandIndex++), mode, getInfo(EmitOp::General));
}
@@ -2635,38 +2678,38 @@ void CLikeSourceEmitter::emitIntrinsicCallExpr(
{
// Looks like a member function call
emitIROperand(inst->getOperand(operandIndex), mode, leftSide(outerPrec, prec));
- m_stream->emit(".");
+ m_writer->emit(".");
operandIndex++;
}
// fixing issue #602 for GLSL sign function: https://github.com/shader-slang/slang/issues/602
- bool glslSignFix = getTarget() == CodeGenTarget::GLSL && name == "sign";
+ bool glslSignFix = getSourceStyle() == SourceStyle::GLSL && name == "sign";
if (glslSignFix)
{
if (auto vectorType = as<IRVectorType>(inst->getDataType()))
{
- m_stream->emit("ivec");
- m_stream->emit(as<IRConstant>(vectorType->getElementCount())->value.intVal);
- m_stream->emit("(");
+ m_writer->emit("ivec");
+ m_writer->emit(as<IRConstant>(vectorType->getElementCount())->value.intVal);
+ m_writer->emit("(");
}
else if (auto scalarType = as<IRBasicType>(inst->getDataType()))
{
- m_stream->emit("int(");
+ m_writer->emit("int(");
}
else
glslSignFix = false;
}
- m_stream->emit(name);
- m_stream->emit("(");
+ m_writer->emit(name);
+ m_writer->emit("(");
bool first = true;
for(; operandIndex < operandCount; ++operandIndex )
{
- if(!first) m_stream->emit(", ");
+ if(!first) m_writer->emit(", ");
emitIROperand(inst->getOperand(operandIndex), mode, getInfo(EmitOp::General));
first = false;
}
- m_stream->emit(")");
+ m_writer->emit(")");
if (glslSignFix)
- m_stream->emit(")");
+ m_writer->emit(")");
maybeCloseParens(needClose);
}
@@ -2676,7 +2719,7 @@ void CLikeSourceEmitter::emitIRCallExpr(IRCall* inst, IREmitMode mode, EmitOpInf
// Does this function declare any requirements on GLSL version or
// extensions, which should affect our output?
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
auto decoratedValue = funcValue;
while (auto specInst = as<IRSpecialize>(decoratedValue))
@@ -2714,17 +2757,17 @@ void CLikeSourceEmitter::emitIRCallExpr(IRCall* inst, IREmitMode mode, EmitOpInf
bool needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(funcValue, mode, leftSide(outerPrec, prec));
- m_stream->emit("(");
+ m_writer->emit("(");
UInt argCount = inst->getOperandCount();
for( UInt aa = 1; aa < argCount; ++aa )
{
auto operand = inst->getOperand(aa);
if (as<IRVoidType>(operand->getDataType()))
continue;
- if(aa != 1) m_stream->emit(", ");
+ if(aa != 1) m_writer->emit(", ");
emitIROperand(inst->getOperand(aa), mode, getInfo(EmitOp::General));
}
- m_stream->emit(")");
+ m_writer->emit(")");
maybeCloseParens(needClose);
}
@@ -2753,12 +2796,12 @@ void CLikeSourceEmitter::_maybeEmitGLSLCast(IRType* castType, IRInst* inst, IREm
if (castType)
{
emitIRType(castType);
- m_stream->emit("(");
+ m_writer->emit("(");
// Emit the operand
emitIROperand(inst, mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
else
{
@@ -2771,7 +2814,7 @@ void CLikeSourceEmitter::emitNot(IRInst* inst, IREmitMode mode, EmitOpInfo& ioOu
{
IRInst* operand = inst->getOperand(0);
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
if (auto vectorType = as<IRVectorType>(operand->getDataType()))
{
@@ -2779,9 +2822,9 @@ void CLikeSourceEmitter::emitNot(IRInst* inst, IREmitMode mode, EmitOpInfo& ioOu
auto prec = getInfo(EmitOp::Postfix);
*outNeedClose = maybeEmitParens(ioOuterPrec, prec);
- m_stream->emit("not(");
+ m_writer->emit("not(");
emitIROperand(operand, mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
return;
}
}
@@ -2789,14 +2832,14 @@ void CLikeSourceEmitter::emitNot(IRInst* inst, IREmitMode mode, EmitOpInfo& ioOu
auto prec = getInfo(EmitOp::Prefix);
*outNeedClose = maybeEmitParens(ioOuterPrec, prec);
- m_stream->emit("!");
+ m_writer->emit("!");
emitIROperand(operand, mode, rightSide(prec, ioOuterPrec));
}
void CLikeSourceEmitter::emitComparison(IRInst* inst, IREmitMode mode, EmitOpInfo& ioOuterPrec, const EmitOpInfo& opPrec, bool* needCloseOut)
{
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
IRInst* left = inst->getOperand(0);
IRInst* right = inst->getOperand(1);
@@ -2817,12 +2860,12 @@ void CLikeSourceEmitter::emitComparison(IRInst* inst, IREmitMode mode, EmitOpInf
auto prec = getInfo(EmitOp::Postfix);
*needCloseOut = maybeEmitParens(ioOuterPrec, prec);
- m_stream->emit(funcName);
- m_stream->emit("(");
+ m_writer->emit(funcName);
+ m_writer->emit("(");
_maybeEmitGLSLCast((leftVectorType ? nullptr : vecType), left, mode);
- m_stream->emit(",");
+ m_writer->emit(",");
_maybeEmitGLSLCast((rightVectorType ? nullptr : vecType), right, mode);
- m_stream->emit(")");
+ m_writer->emit(")");
return;
}
@@ -2831,9 +2874,9 @@ void CLikeSourceEmitter::emitComparison(IRInst* inst, IREmitMode mode, EmitOpInf
*needCloseOut = maybeEmitParens(ioOuterPrec, opPrec);
emitIROperand(inst->getOperand(0), mode, leftSide(ioOuterPrec, opPrec));
- m_stream->emit(" ");
- m_stream->emit(opPrec.op);
- m_stream->emit(" ");
+ m_writer->emit(" ");
+ m_writer->emit(opPrec.op);
+ m_writer->emit(" ");
emitIROperand(inst->getOperand(1), mode, rightSide(ioOuterPrec, opPrec));
}
@@ -2855,9 +2898,9 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
case kIROp_MakeMatrix:
// Simple constructor call
- switch (getTarget())
+ switch (getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
{
if (inst->getOperandCount() == 1)
{
@@ -2865,22 +2908,22 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
// Need to emit as cast for HLSL
- m_stream->emit("(");
+ m_writer->emit("(");
emitIRType(inst->getDataType());
- m_stream->emit(") ");
+ m_writer->emit(") ");
emitIROperand(inst->getOperand(0), mode, rightSide(outerPrec, prec));
break;
}
/* fallthru*/
}
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
{
emitIRType(inst->getDataType());
emitIRArgs(inst, mode);
break;
}
- case CodeGenTarget::CPPSource:
- case CodeGenTarget::CSource:
+ case SourceStyle::CPP:
+ case SourceStyle::C:
{
if (inst->getOperandCount() == 1)
{
@@ -2899,14 +2942,14 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
case kIROp_constructVectorFromScalar:
// Simple constructor call
- if( getTarget() == CodeGenTarget::HLSL )
+ if( getSourceStyle() == SourceStyle::HLSL )
{
auto prec = getInfo(EmitOp::Prefix);
needClose = maybeEmitParens(outerPrec, prec);
- m_stream->emit("(");
+ m_writer->emit("(");
emitIRType(inst->getDataType());
- m_stream->emit(")");
+ m_writer->emit(")");
emitIROperand(inst->getOperand(0), mode, rightSide(outerPrec,prec));
}
@@ -2916,9 +2959,9 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
emitIRType(inst->getDataType());
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(inst->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
break;
@@ -2933,13 +2976,13 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto base = fieldExtract->getBase();
emitIROperand(base, mode, leftSide(outerPrec, prec));
- m_stream->emit(".");
- if(getTarget() == CodeGenTarget::GLSL
+ m_writer->emit(".");
+ if(getSourceStyle() == SourceStyle::GLSL
&& as<IRUniformParameterGroupType>(base->getDataType()))
{
- m_stream->emit("_data.");
+ m_writer->emit("_data.");
}
- m_stream->emit(getIRName(fieldExtract->getField()));
+ m_writer->emit(getIRName(fieldExtract->getField()));
}
break;
@@ -2954,13 +2997,13 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto base = ii->getBase();
emitIROperand(base, mode, leftSide(outerPrec, prec));
- m_stream->emit(".");
- if(getTarget() == CodeGenTarget::GLSL
+ m_writer->emit(".");
+ if(getSourceStyle() == SourceStyle::GLSL
&& as<IRUniformParameterGroupType>(base->getDataType()))
{
- m_stream->emit("_data.");
+ m_writer->emit("_data.");
}
- m_stream->emit(getIRName(ii->getField()));
+ m_writer->emit(getIRName(ii->getField()));
}
break;
@@ -2974,7 +3017,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
case OPCODE: \
needClose = maybeEmitParens(outerPrec, getInfo(EmitOp::PREC)); \
emitIROperand(inst->getOperand(0), mode, leftSide(outerPrec, getInfo(EmitOp::PREC))); \
- m_stream->emit(" " #OP " "); \
+ m_writer->emit(" " #OP " "); \
emitIROperand(inst->getOperand(1), mode, rightSide(outerPrec, getInfo(EmitOp::PREC))); \
break
@@ -3007,15 +3050,15 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
// when working with matrices.
case kIROp_Mul:
// Are we targetting GLSL, and are both operands matrices?
- if(getTarget() == CodeGenTarget::GLSL
+ if(getSourceStyle() == SourceStyle::GLSL
&& as<IRMatrixType>(inst->getOperand(0)->getDataType())
&& as<IRMatrixType>(inst->getOperand(1)->getDataType()))
{
- m_stream->emit("matrixCompMult(");
+ m_writer->emit("matrixCompMult(");
emitIROperand(inst->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit(", ");
+ m_writer->emit(", ");
emitIROperand(inst->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
else
{
@@ -3024,7 +3067,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto prec = getInfo(EmitOp::Mul);
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(inst->getOperand(0), mode, leftSide(outerPrec, prec));
- m_stream->emit(" * ");
+ m_writer->emit(" * ");
emitIROperand(inst->getOperand(1), mode, rightSide(prec, outerPrec));
}
break;
@@ -3040,7 +3083,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto prec = getInfo(EmitOp::Prefix);
needClose = maybeEmitParens(outerPrec, prec);
- m_stream->emit("-");
+ m_writer->emit("-");
emitIROperand(inst->getOperand(0), mode, rightSide(prec, outerPrec));
}
break;
@@ -3052,11 +3095,11 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
if (as<IRBoolType>(inst->getDataType()))
{
- m_stream->emit("!");
+ m_writer->emit("!");
}
else
{
- m_stream->emit("~");
+ m_writer->emit("~");
}
emitIROperand(inst->getOperand(0), mode, rightSide(prec, outerPrec));
}
@@ -3074,15 +3117,15 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
// Are we targetting GLSL, and are both operands scalar bools?
// In that case convert the operation to a logical And
- if (getTarget() == CodeGenTarget::GLSL
+ if (getSourceStyle() == SourceStyle::GLSL
&& as<IRBoolType>(inst->getOperand(0)->getDataType())
&& as<IRBoolType>(inst->getOperand(1)->getDataType()))
{
- m_stream->emit("&&");
+ m_writer->emit("&&");
}
else
{
- m_stream->emit("&");
+ m_writer->emit("&");
}
emitIROperand(inst->getOperand(1), mode, rightSide(outerPrec, prec));
@@ -3101,15 +3144,15 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
// Are we targetting GLSL, and are both operands scalar bools?
// In that case convert the operation to a logical Or
- if (getTarget() == CodeGenTarget::GLSL
+ if (getSourceStyle() == SourceStyle::GLSL
&& as<IRBoolType>(inst->getOperand(0)->getDataType())
&& as<IRBoolType>(inst->getOperand(1)->getDataType()))
{
- m_stream->emit("||");
+ m_writer->emit("||");
}
else
{
- m_stream->emit("|");
+ m_writer->emit("|");
}
emitIROperand(inst->getOperand(1), mode, rightSide(outerPrec, prec));
@@ -3120,10 +3163,10 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
{
auto base = inst->getOperand(0);
emitIROperand(base, mode, outerPrec);
- if(getTarget() == CodeGenTarget::GLSL
+ if(getSourceStyle() == SourceStyle::GLSL
&& as<IRUniformParameterGroupType>(base->getDataType()))
{
- m_stream->emit("._data");
+ m_writer->emit("._data");
}
}
break;
@@ -3134,7 +3177,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(inst->getOperand(0), mode, leftSide(outerPrec, prec));
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
emitIROperand(inst->getOperand(1), mode, rightSide(prec, outerPrec));
}
break;
@@ -3146,7 +3189,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
break;
case kIROp_GroupMemoryBarrierWithGroupSync:
- m_stream->emit("GroupMemoryBarrierWithGroupSync()");
+ m_writer->emit("GroupMemoryBarrierWithGroupSync()");
break;
case kIROp_getElement:
@@ -3158,10 +3201,10 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto prec = getInfo(EmitOp::Postfix);
needClose = maybeEmitParens(outerPrec, prec);
- m_stream->emit(decoration->getOuterArrayName());
- m_stream->emit("[");
+ m_writer->emit(decoration->getOuterArrayName());
+ m_writer->emit("[");
emitIROperand(inst->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit("].");
+ m_writer->emit("].");
emitIROperand(inst->getOperand(0), mode, rightSide(prec, outerPrec));
break;
}
@@ -3171,16 +3214,16 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand( inst->getOperand(0), mode, leftSide(outerPrec, prec));
- m_stream->emit("[");
+ m_writer->emit("[");
emitIROperand(inst->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit("]");
+ m_writer->emit("]");
}
break;
case kIROp_Mul_Vector_Matrix:
case kIROp_Mul_Matrix_Vector:
case kIROp_Mul_Matrix_Matrix:
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
// GLSL expresses inner-product multiplications
// with the ordinary infix `*` operator.
@@ -3194,16 +3237,16 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(inst->getOperand(1), mode, leftSide(outerPrec, prec));
- m_stream->emit(" * ");
+ m_writer->emit(" * ");
emitIROperand(inst->getOperand(0), mode, rightSide(prec, outerPrec));
}
else
{
- m_stream->emit("mul(");
+ m_writer->emit("mul(");
emitIROperand(inst->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit(", ");
+ m_writer->emit(", ");
emitIROperand(inst->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
break;
@@ -3214,7 +3257,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
auto ii = (IRSwizzle*)inst;
emitIROperand(ii->getBase(), mode, leftSide(outerPrec, prec));
- m_stream->emit(".");
+ m_writer->emit(".");
const Index elementCount = Index(ii->getElementCount());
for (Index ee = 0; ee < elementCount; ++ee)
{
@@ -3226,7 +3269,7 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
SLANG_RELEASE_ASSERT(elementIndex < 4);
char const* kComponents[] = { "x", "y", "z", "w" };
- m_stream->emit(kComponents[elementIndex]);
+ m_writer->emit(kComponents[elementIndex]);
}
}
break;
@@ -3239,17 +3282,17 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
case kIROp_Select:
{
- if (getTarget() == CodeGenTarget::GLSL &&
+ if (getSourceStyle() == SourceStyle::GLSL &&
inst->getOperand(0)->getDataType()->op != kIROp_BoolType)
{
// For GLSL, emit a call to `mix` if condition is a vector
- m_stream->emit("mix(");
+ m_writer->emit("mix(");
emitIROperand(inst->getOperand(2), mode, leftSide(getInfo(EmitOp::General), getInfo(EmitOp::General)));
- m_stream->emit(", ");
+ m_writer->emit(", ");
emitIROperand(inst->getOperand(1), mode, leftSide(getInfo(EmitOp::General), getInfo(EmitOp::General)));
- m_stream->emit(", ");
+ m_writer->emit(", ");
emitIROperand(inst->getOperand(0), mode, leftSide(getInfo(EmitOp::General), getInfo(EmitOp::General)));
- m_stream->emit(")");
+ m_writer->emit(")");
}
else
{
@@ -3257,16 +3300,16 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
needClose = maybeEmitParens(outerPrec, prec);
emitIROperand(inst->getOperand(0), mode, leftSide(outerPrec, prec));
- m_stream->emit(" ? ");
+ m_writer->emit(" ? ");
emitIROperand(inst->getOperand(1), mode, prec);
- m_stream->emit(" : ");
+ m_writer->emit(" : ");
emitIROperand(inst->getOperand(2), mode, rightSide(prec, outerPrec));
}
}
break;
case kIROp_Param:
- m_stream->emit(getIRName(inst));
+ m_writer->emit(getIRName(inst));
break;
case kIROp_makeArray:
@@ -3276,14 +3319,14 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
// be appropriate, depending on the context
// of the expression.
- m_stream->emit("{ ");
+ m_writer->emit("{ ");
UInt argCount = inst->getOperandCount();
for (UInt aa = 0; aa < argCount; ++aa)
{
- if (aa != 0) m_stream->emit(", ");
+ if (aa != 0) m_writer->emit(", ");
emitIROperand(inst->getOperand(aa), mode, getInfo(EmitOp::General));
}
- m_stream->emit(" }");
+ m_writer->emit(" }");
}
break;
@@ -3299,13 +3342,13 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
//
// auto fromType = extractBaseType(inst->getOperand(0)->getDataType());
auto toType = extractBaseType(inst->getDataType());
- switch(getTarget())
+ switch(getSourceStyle())
{
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
switch(toType)
{
default:
- m_stream->emit("/* unhandled */");
+ m_writer->emit("/* unhandled */");
break;
case BaseType::UInt:
@@ -3316,27 +3359,27 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
break;
case BaseType::Float:
- m_stream->emit("uintBitsToFloat(");
+ m_writer->emit("uintBitsToFloat(");
break;
}
break;
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
switch(toType)
{
default:
- m_stream->emit("/* unhandled */");
+ m_writer->emit("/* unhandled */");
break;
case BaseType::UInt:
break;
case BaseType::Int:
- m_stream->emit("(");
+ m_writer->emit("(");
emitIRType(inst->getDataType());
- m_stream->emit(")");
+ m_writer->emit(")");
break;
case BaseType::Float:
- m_stream->emit("asfloat");
+ m_writer->emit("asfloat");
break;
}
break;
@@ -3347,14 +3390,14 @@ void CLikeSourceEmitter::emitIRInstExpr(IRInst* inst, IREmitMode mode, const Emi
break;
}
- m_stream->emit("(");
+ m_writer->emit("(");
emitIROperand(inst->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit(")");
+ m_writer->emit(")");
}
break;
default:
- m_stream->emit("/* unhandled */");
+ m_writer->emit("/* unhandled */");
break;
}
maybeCloseParens(needClose);
@@ -3385,40 +3428,40 @@ void CLikeSourceEmitter::emitIRInst(IRInst* inst, IREmitMode mode)
{
try
{
- emitIRInstImpl(inst, mode);
+ _emitIRInst(inst, mode);
}
// Don't emit any context message for an explicit `AbortCompilationException`
// because it should only happen when an error is already emitted.
catch(AbortCompilationException&) { throw; }
catch(...)
{
- m_context->noteInternalErrorLoc(inst->sourceLoc);
+ noteInternalErrorLoc(inst->sourceLoc);
throw;
}
}
-void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
+void CLikeSourceEmitter::_emitIRInst(IRInst* inst, IREmitMode mode)
{
if (shouldFoldIRInstIntoUseSites(inst, mode))
{
return;
}
- m_stream->advanceToSourceLocation(inst->sourceLoc);
+ m_writer->advanceToSourceLocation(inst->sourceLoc);
switch(inst->op)
{
default:
emitIRInstResultDecl(inst);
emitIRInstExpr(inst, mode, getInfo(EmitOp::General));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
break;
case kIROp_undefined:
{
auto type = inst->getDataType();
emitIRType(type, getIRName(inst));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
break;
@@ -3430,7 +3473,7 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
auto name = getIRName(inst);
emitIRRateQualifiers(inst);
emitIRType(valType, name);
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
break;
@@ -3444,17 +3487,17 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
break;
case kIROp_ReturnVoid:
- m_stream->emit("return;\n");
+ m_writer->emit("return;\n");
break;
case kIROp_ReturnVal:
- m_stream->emit("return ");
+ m_writer->emit("return ");
emitIROperand(((IRReturnVal*) inst)->getVal(), mode, getInfo(EmitOp::General));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
break;
case kIROp_discard:
- m_stream->emit("discard;\n");
+ m_writer->emit("discard;\n");
break;
case kIROp_swizzleSet:
@@ -3462,14 +3505,14 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
auto ii = (IRSwizzleSet*)inst;
emitIRInstResultDecl(inst);
emitIROperand(inst->getOperand(0), mode, getInfo(EmitOp::General));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
auto subscriptOuter = getInfo(EmitOp::General);
auto subscriptPrec = getInfo(EmitOp::Postfix);
bool needCloseSubscript = maybeEmitParens(subscriptOuter, subscriptPrec);
emitIROperand(inst, mode, leftSide(subscriptOuter, subscriptPrec));
- m_stream->emit(".");
+ m_writer->emit(".");
UInt elementCount = ii->getElementCount();
for (UInt ee = 0; ee < elementCount; ++ee)
{
@@ -3481,13 +3524,13 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
SLANG_RELEASE_ASSERT(elementIndex < 4);
char const* kComponents[] = { "x", "y", "z", "w" };
- m_stream->emit(kComponents[elementIndex]);
+ m_writer->emit(kComponents[elementIndex]);
}
maybeCloseParens(needCloseSubscript);
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
emitIROperand(inst->getOperand(1), mode, getInfo(EmitOp::General));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
break;
@@ -3500,7 +3543,7 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
auto ii = cast<IRSwizzledStore>(inst);
emitIROperand(ii->getDest(), mode, leftSide(subscriptOuter, subscriptPrec));
- m_stream->emit(".");
+ m_writer->emit(".");
UInt elementCount = ii->getElementCount();
for (UInt ee = 0; ee < elementCount; ++ee)
{
@@ -3512,13 +3555,13 @@ void CLikeSourceEmitter::emitIRInstImpl(IRInst* inst, IREmitMode mode)
SLANG_RELEASE_ASSERT(elementIndex < 4);
char const* kComponents[] = { "x", "y", "z", "w" };
- m_stream->emit(kComponents[elementIndex]);
+ m_writer->emit(kComponents[elementIndex]);
}
maybeCloseParens(needCloseSubscript);
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
emitIROperand(ii->getSource(), mode, getInfo(EmitOp::General));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
break;
}
@@ -3528,11 +3571,11 @@ void CLikeSourceEmitter::emitIRSemantics(VarLayout* varLayout)
{
if(varLayout->flags & VarLayoutFlag::HasSemantic)
{
- m_stream->emit(" : ");
- m_stream->emit(varLayout->semanticName);
+ m_writer->emit(" : ");
+ m_writer->emit(varLayout->semanticName);
if(varLayout->semanticIndex)
{
- m_stream->emit(varLayout->semanticIndex);
+ m_writer->emit(varLayout->semanticIndex);
}
}
}
@@ -3540,9 +3583,9 @@ void CLikeSourceEmitter::emitIRSemantics(VarLayout* varLayout)
void CLikeSourceEmitter::emitIRSemantics(IRInst* inst)
{
// Don't emit semantics if we aren't translating down to HLSL
- switch (getTarget())
+ switch (getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
break;
default:
@@ -3551,8 +3594,8 @@ void CLikeSourceEmitter::emitIRSemantics(IRInst* inst)
if (auto semanticDecoration = inst->findDecoration<IRSemanticDecoration>())
{
- m_stream->emit(" : ");
- m_stream->emit(semanticDecoration->getSemanticName());
+ m_writer->emit(" : ");
+ m_writer->emit(semanticDecoration->getSemanticName());
return;
}
@@ -3610,9 +3653,9 @@ void CLikeSourceEmitter::emitPhiVarAssignments(UInt argCount, IRUse* args, IRBlo
auto prec = getInfo(EmitOp::Assign);
emitIROperand(pp, IREmitMode::Default, leftSide(outerPrec, prec));
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
emitIROperand(arg, IREmitMode::Default, rightSide(prec, outerPrec));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
}
@@ -3650,7 +3693,7 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
// of terminators are simple enough that we just fold
// them into the current block.
//
- m_stream->advanceToSourceLocation(terminator->sourceLoc);
+ m_writer->advanceToSourceLocation(terminator->sourceLoc);
switch(terminator->op)
{
default:
@@ -3721,10 +3764,10 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
// don't need to consider multi-level break/continue (which we
// don't for now).
case Region::Flavor::Break:
- m_stream->emit("break;\n");
+ m_writer->emit("break;\n");
break;
case Region::Flavor::Continue:
- m_stream->emit("continue;\n");
+ m_writer->emit("continue;\n");
break;
case Region::Flavor::If:
@@ -3736,23 +3779,23 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
// so that we output `if(!condition) { elseRegion }`
// instead of the current `if(condition) {} else { elseRegion }`
- m_stream->emit("if(");
+ m_writer->emit("if(");
emitIROperand(ifRegion->condition, IREmitMode::Default, getInfo(EmitOp::General));
- m_stream->emit(")\n{\n");
- m_stream->indent();
+ m_writer->emit(")\n{\n");
+ m_writer->indent();
emitRegion(ifRegion->thenRegion);
- m_stream->dedent();
- m_stream->emit("}\n");
+ m_writer->dedent();
+ m_writer->emit("}\n");
// Don't emit the `else` region if it would be empty
//
if(auto elseRegion = ifRegion->elseRegion)
{
- m_stream->emit("else\n{\n");
- m_stream->indent();
+ m_writer->emit("else\n{\n");
+ m_writer->indent();
emitRegion(elseRegion);
- m_stream->dedent();
- m_stream->emit("}\n");
+ m_writer->dedent();
+ m_writer->emit("}\n");
}
// Continue with the region after the `if`.
@@ -3783,9 +3826,9 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
{
case kIRLoopControl_Unroll:
// Note: loop unrolling control is only available in HLSL, not GLSL
- if(getTarget() == CodeGenTarget::HLSL)
+ if(getSourceStyle() == SourceStyle::HLSL)
{
- m_stream->emit("[unroll]\n");
+ m_writer->emit("[unroll]\n");
}
break;
@@ -3794,11 +3837,11 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
}
}
- m_stream->emit("for(;;)\n{\n");
- m_stream->indent();
+ m_writer->emit("for(;;)\n{\n");
+ m_writer->indent();
emitRegion(loopRegion->body);
- m_stream->dedent();
- m_stream->emit("}\n");
+ m_writer->dedent();
+ m_writer->emit("}\n");
// Continue with the region after the loop
region = loopRegion->nextRegion;
@@ -3810,34 +3853,34 @@ void CLikeSourceEmitter::emitRegion(Region* inRegion)
auto switchRegion = (SwitchRegion*) region;
// Emit the start of our statement.
- m_stream->emit("switch(");
+ m_writer->emit("switch(");
emitIROperand(switchRegion->condition, IREmitMode::Default, getInfo(EmitOp::General));
- m_stream->emit(")\n{\n");
+ m_writer->emit(")\n{\n");
auto defaultCase = switchRegion->defaultCase;
for(auto currentCase : switchRegion->cases)
{
for(auto caseVal : currentCase->values)
{
- m_stream->emit("case ");
+ m_writer->emit("case ");
emitIROperand(caseVal, IREmitMode::Default, getInfo(EmitOp::General));
- m_stream->emit(":\n");
+ m_writer->emit(":\n");
}
if(currentCase.Ptr() == defaultCase)
{
- m_stream->emit("default:\n");
+ m_writer->emit("default:\n");
}
- m_stream->indent();
- m_stream->emit("{\n");
- m_stream->indent();
+ m_writer->indent();
+ m_writer->emit("{\n");
+ m_writer->indent();
emitRegion(currentCase->body);
- m_stream->dedent();
- m_stream->emit("}\n");
- m_stream->dedent();
+ m_writer->dedent();
+ m_writer->emit("}\n");
+ m_writer->dedent();
}
- m_stream->emit("}\n");
+ m_writer->emit("}\n");
// Continue with the region after the `switch`
region = switchRegion->nextRegion;
@@ -3874,7 +3917,7 @@ String CLikeSourceEmitter::getIRFuncName(IRFunc* func)
// that wraps this know to use `main` instead
// of the original entry-point name...
//
- if (getTarget() != CodeGenTarget::GLSL)
+ if (getSourceStyle() != SourceStyle::GLSL)
{
return getText(entryPointLayout->entryPoint->getName());
}
@@ -3909,11 +3952,11 @@ void CLikeSourceEmitter::emitAttributeSingleString(const char* name, FuncDecl* e
return;
}
- m_stream->emit("[");
- m_stream->emit(name);
- m_stream->emit("(\"");
- m_stream->emit(stringLitExpr->value);
- m_stream->emit("\")]\n");
+ m_writer->emit("[");
+ m_writer->emit(name);
+ m_writer->emit("(\"");
+ m_writer->emit(stringLitExpr->value);
+ m_writer->emit("\")]\n");
}
void CLikeSourceEmitter::emitAttributeSingleInt(const char* name, FuncDecl* entryPoint, Attribute* attrib)
@@ -3936,11 +3979,11 @@ void CLikeSourceEmitter::emitAttributeSingleInt(const char* name, FuncDecl* entr
return;
}
- m_stream->emit("[");
- m_stream->emit(name);
- m_stream->emit("(");
- m_stream->emit(intLitExpr->value);
- m_stream->emit(")]\n");
+ m_writer->emit("[");
+ m_writer->emit(name);
+ m_writer->emit("(");
+ m_writer->emit(intLitExpr->value);
+ m_writer->emit(")]\n");
}
void CLikeSourceEmitter::emitFuncDeclPatchConstantFuncAttribute(IRFunc* irFunc, FuncDecl* entryPoint, PatchConstantFuncAttribute* attrib)
@@ -3957,14 +4000,14 @@ void CLikeSourceEmitter::emitFuncDeclPatchConstantFuncAttribute(IRFunc* irFunc,
const String irName = getIRName(irPatchFunc->getFunc());
- m_stream->emit("[patchconstantfunc(\"");
- m_stream->emit(irName);
- m_stream->emit("\")]\n");
+ m_writer->emit("[patchconstantfunc(\"");
+ m_writer->emit(irName);
+ m_writer->emit("\")]\n");
}
void CLikeSourceEmitter::emitIREntryPointAttributes_HLSL(IRFunc* irFunc, EntryPointLayout* entryPointLayout)
{
- auto profile = m_context->effectiveProfile;
+ auto profile = m_effectiveProfile;
auto stage = entryPointLayout->profile.GetStage();
if(profile.getFamily() == ProfileFamily::DX)
@@ -3974,9 +4017,9 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_HLSL(IRFunc* irFunc, EntryPo
char const* stageName = getStageName(stage);
if(stageName)
{
- m_stream->emit("[shader(\"");
- m_stream->emit(stageName);
- m_stream->emit("\")]");
+ m_writer->emit("[shader(\"");
+ m_writer->emit(stageName);
+ m_writer->emit("\")]");
}
}
}
@@ -3996,28 +4039,28 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_HLSL(IRFunc* irFunc, EntryPo
kAxisCount,
&sizeAlongAxis[0]);
- m_stream->emit("[numthreads(");
+ m_writer->emit("[numthreads(");
for (int ii = 0; ii < 3; ++ii)
{
- if (ii != 0) m_stream->emit(", ");
- m_stream->emit(sizeAlongAxis[ii]);
+ if (ii != 0) m_writer->emit(", ");
+ m_writer->emit(sizeAlongAxis[ii]);
}
- m_stream->emit(")]\n");
+ m_writer->emit(")]\n");
}
break;
case Stage::Geometry:
{
if (auto attrib = entryPointLayout->entryPoint->FindModifier<MaxVertexCountAttribute>())
{
- m_stream->emit("[maxvertexcount(");
- m_stream->emit(attrib->value);
- m_stream->emit(")]\n");
+ m_writer->emit("[maxvertexcount(");
+ m_writer->emit(attrib->value);
+ m_writer->emit(")]\n");
}
if (auto attrib = entryPointLayout->entryPoint->FindModifier<InstanceAttribute>())
{
- m_stream->emit("[instance(");
- m_stream->emit(attrib->value);
- m_stream->emit(")]\n");
+ m_writer->emit("[instance(");
+ m_writer->emit(attrib->value);
+ m_writer->emit(")]\n");
}
break;
}
@@ -4071,7 +4114,7 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_HLSL(IRFunc* irFunc, EntryPo
{
if (irFunc->findDecoration<IREarlyDepthStencilDecoration>())
{
- m_stream->emit("[earlydepthstencil]\n");
+ m_writer->emit("[earlydepthstencil]\n");
}
break;
}
@@ -4101,32 +4144,32 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_GLSL(IRFunc* irFunc, EntryPo
kAxisCount,
&sizeAlongAxis[0]);
- m_stream->emit("layout(");
+ m_writer->emit("layout(");
char const* axes[] = { "x", "y", "z" };
for (int ii = 0; ii < 3; ++ii)
{
- if (ii != 0) m_stream->emit(", ");
- m_stream->emit("local_size_");
- m_stream->emit(axes[ii]);
- m_stream->emit(" = ");
- m_stream->emit(sizeAlongAxis[ii]);
+ if (ii != 0) m_writer->emit(", ");
+ m_writer->emit("local_size_");
+ m_writer->emit(axes[ii]);
+ m_writer->emit(" = ");
+ m_writer->emit(sizeAlongAxis[ii]);
}
- m_stream->emit(") in;");
+ m_writer->emit(") in;");
}
break;
case Stage::Geometry:
{
if (auto attrib = entryPointLayout->entryPoint->FindModifier<MaxVertexCountAttribute>())
{
- m_stream->emit("layout(max_vertices = ");
- m_stream->emit(attrib->value);
- m_stream->emit(") out;\n");
+ m_writer->emit("layout(max_vertices = ");
+ m_writer->emit(attrib->value);
+ m_writer->emit(") out;\n");
}
if (auto attrib = entryPointLayout->entryPoint->FindModifier<InstanceAttribute>())
{
- m_stream->emit("layout(invocations = ");
- m_stream->emit(attrib->value);
- m_stream->emit(") in;\n");
+ m_writer->emit("layout(invocations = ");
+ m_writer->emit(attrib->value);
+ m_writer->emit(") in;\n");
}
for(auto pp : entryPointLayout->entryPoint->GetParameters())
@@ -4135,23 +4178,23 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_GLSL(IRFunc* irFunc, EntryPo
{
if(as<HLSLTriangleModifier>(inputPrimitiveTypeModifier))
{
- m_stream->emit("layout(triangles) in;\n");
+ m_writer->emit("layout(triangles) in;\n");
}
else if(as<HLSLLineModifier>(inputPrimitiveTypeModifier))
{
- m_stream->emit("layout(lines) in;\n");
+ m_writer->emit("layout(lines) in;\n");
}
else if(as<HLSLLineAdjModifier>(inputPrimitiveTypeModifier))
{
- m_stream->emit("layout(lines_adjacency) in;\n");
+ m_writer->emit("layout(lines_adjacency) in;\n");
}
else if(as<HLSLPointModifier>(inputPrimitiveTypeModifier))
{
- m_stream->emit("layout(points) in;\n");
+ m_writer->emit("layout(points) in;\n");
}
else if(as<HLSLTriangleAdjModifier>(inputPrimitiveTypeModifier))
{
- m_stream->emit("layout(triangles_adjacency) in;\n");
+ m_writer->emit("layout(triangles_adjacency) in;\n");
}
}
@@ -4159,15 +4202,15 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_GLSL(IRFunc* irFunc, EntryPo
{
if(as<HLSLTriangleStreamType>(outputStreamType))
{
- m_stream->emit("layout(triangle_strip) out;\n");
+ m_writer->emit("layout(triangle_strip) out;\n");
}
else if(as<HLSLLineStreamType>(outputStreamType))
{
- m_stream->emit("layout(line_strip) out;\n");
+ m_writer->emit("layout(line_strip) out;\n");
}
else if(as<HLSLPointStreamType>(outputStreamType))
{
- m_stream->emit("layout(points) out;\n");
+ m_writer->emit("layout(points) out;\n");
}
}
}
@@ -4180,7 +4223,7 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_GLSL(IRFunc* irFunc, EntryPo
if (irFunc->findDecoration<IREarlyDepthStencilDecoration>())
{
// https://www.khronos.org/opengl/wiki/Early_Fragment_Test
- m_stream->emit("layout(early_fragment_tests) in;\n");
+ m_writer->emit("layout(early_fragment_tests) in;\n");
}
break;
}
@@ -4192,13 +4235,13 @@ void CLikeSourceEmitter::emitIREntryPointAttributes_GLSL(IRFunc* irFunc, EntryPo
void CLikeSourceEmitter::emitIREntryPointAttributes(IRFunc* irFunc, EntryPointLayout* entryPointLayout)
{
- switch(getTarget())
+ switch(getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
emitIREntryPointAttributes_HLSL(irFunc, entryPointLayout);
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
emitIREntryPointAttributes_GLSL(irFunc, entryPointLayout);
break;
}
@@ -4219,7 +4262,7 @@ void CLikeSourceEmitter::emitPhiVarDecls(IRFunc* func)
{
emitIRTempModifiers(pp);
emitIRType(pp->getFullType(), getIRName(pp));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
}
}
@@ -4230,9 +4273,7 @@ void CLikeSourceEmitter::emitIRFunctionBody(IRGlobalValueWithCode* code)
// Compute a structured region tree that can represent
// the control flow of our function.
//
- RefPtr<RegionTree> regionTree = generateRegionTreeForFunc(
- code,
- m_context->getSink());
+ RefPtr<RegionTree> regionTree = generateRegionTreeForFunc(code, getSink());
// Now that we've computed the region tree, we have
// an opportunity to perform some last-minute transformations
@@ -4267,23 +4308,21 @@ void CLikeSourceEmitter::emitIRSimpleFunc(IRFunc* func)
emitIREntryPointAttributes(func, entryPointLayout);
}
- const CodeGenTarget target = getTarget();
-
auto name = getIRFuncName(func);
emitType(resultType, name);
- m_stream->emit("(");
+ m_writer->emit("(");
auto firstParam = func->getFirstParam();
for( auto pp = firstParam; pp; pp = pp->getNextParam())
{
if(pp != firstParam)
- m_stream->emit(", ");
+ m_writer->emit(", ");
auto paramName = getIRName(pp);
auto paramType = pp->getDataType();
- if (target == CodeGenTarget::HLSL)
+ if (getSourceStyle() == SourceStyle::HLSL)
{
if (auto layoutDecor = pp->findDecoration<IRLayoutDecoration>())
{
@@ -4297,15 +4336,15 @@ void CLikeSourceEmitter::emitIRSimpleFunc(IRFunc* func)
if (auto primTypeModifier = var->FindModifier<HLSLGeometryShaderInputPrimitiveTypeModifier>())
{
if (as<HLSLTriangleModifier>(primTypeModifier))
- m_stream->emit("triangle ");
+ m_writer->emit("triangle ");
else if (as<HLSLPointModifier>(primTypeModifier))
- m_stream->emit("point ");
+ m_writer->emit("point ");
else if (as<HLSLLineModifier>(primTypeModifier))
- m_stream->emit("line ");
+ m_writer->emit("line ");
else if (as<HLSLLineAdjModifier>(primTypeModifier))
- m_stream->emit("lineadj ");
+ m_writer->emit("lineadj ");
else if (as<HLSLTriangleAdjModifier>(primTypeModifier))
- m_stream->emit("triangleadj ");
+ m_writer->emit("triangleadj ");
}
}
}
@@ -4315,15 +4354,15 @@ void CLikeSourceEmitter::emitIRSimpleFunc(IRFunc* func)
emitIRSemantics(pp);
}
- m_stream->emit(")");
+ m_writer->emit(")");
emitIRSemantics(func);
// TODO: encode declaration vs. definition
if(isDefinition(func))
{
- m_stream->emit("\n{\n");
- m_stream->indent();
+ m_writer->emit("\n{\n");
+ m_writer->indent();
// HACK: forward-declare all the local variables needed for the
// parameters of non-entry blocks.
@@ -4332,12 +4371,12 @@ void CLikeSourceEmitter::emitIRSimpleFunc(IRFunc* func)
// Need to emit the operations in the blocks of the function
emitIRFunctionBody(func);
- m_stream->dedent();
- m_stream->emit("}\n\n");
+ m_writer->dedent();
+ m_writer->emit("}\n\n");
}
else
{
- m_stream->emit(";\n\n");
+ m_writer->emit(";\n\n");
}
}
@@ -4349,19 +4388,19 @@ void CLikeSourceEmitter::emitIRParamType(IRType* type, String const& name)
//
if( auto outType = as<IROutType>(type))
{
- m_stream->emit("out ");
+ m_writer->emit("out ");
type = outType->getValueType();
}
else if( auto inOutType = as<IRInOutType>(type))
{
- m_stream->emit("inout ");
+ m_writer->emit("inout ");
type = inOutType->getValueType();
}
else if( auto refType = as<IRRefType>(type))
{
// Note: There is no HLSL/GLSL equivalent for by-reference parameters,
// so we don't actually expect to encounter these in user code.
- m_stream->emit("inout ");
+ m_writer->emit("inout ");
type = inOutType->getValueType();
}
@@ -4414,12 +4453,12 @@ void CLikeSourceEmitter::emitIRFuncDecl(IRFunc* func)
emitIRType(resultType, name);
- m_stream->emit("(");
+ m_writer->emit("(");
auto paramCount = funcType->getParamCount();
for(UInt pp = 0; pp < paramCount; ++pp)
{
if(pp != 0)
- m_stream->emit(", ");
+ m_writer->emit(", ");
String paramName;
paramName.append("_");
@@ -4428,7 +4467,7 @@ void CLikeSourceEmitter::emitIRFuncDecl(IRFunc* func)
emitIRParamType(paramType, paramName);
}
- m_stream->emit(");\n\n");
+ m_writer->emit(");\n\n");
}
EntryPointLayout* CLikeSourceEmitter::getEntryPointLayout(IRFunc* func)
@@ -4515,10 +4554,10 @@ void CLikeSourceEmitter::emitIRStruct(IRStructType* structType)
return;
}
- m_stream->emit("struct ");
- m_stream->emit(getIRName(structType));
- m_stream->emit("\n{\n");
- m_stream->indent();
+ m_writer->emit("struct ");
+ m_writer->emit(getIRName(structType));
+ m_writer->emit("\n{\n");
+ m_writer->indent();
for(auto ff : structType->getFields())
{
@@ -4531,18 +4570,18 @@ void CLikeSourceEmitter::emitIRStruct(IRStructType* structType)
continue;
// Note: GLSL doesn't support interpolation modifiers on `struct` fields
- if( getTarget() != CodeGenTarget::GLSL )
+ if( getSourceStyle() != SourceStyle::GLSL )
{
emitInterpolationModifiers(fieldKey, fieldType, nullptr);
}
emitIRType(fieldType, getIRName(fieldKey));
emitIRSemantics(fieldKey);
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
- m_stream->dedent();
- m_stream->emit("};\n\n");
+ m_writer->dedent();
+ m_writer->emit("};\n\n");
}
void CLikeSourceEmitter::emitIRMatrixLayoutModifiers(VarLayout* layout)
@@ -4557,24 +4596,22 @@ void CLikeSourceEmitter::emitIRMatrixLayoutModifiers(VarLayout* layout)
if (auto matrixTypeLayout = typeLayout.as<MatrixTypeLayout>())
{
- auto target = getTarget();
-
- switch (target)
+ switch (getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
switch (matrixTypeLayout->mode)
{
case kMatrixLayoutMode_ColumnMajor:
- m_stream->emit("column_major ");
+ m_writer->emit("column_major ");
break;
case kMatrixLayoutMode_RowMajor:
- m_stream->emit("row_major ");
+ m_writer->emit("row_major ");
break;
}
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
// Reminder: the meaning of row/column major layout
// in our semantics is the *opposite* of what GLSL
// calls them, because what they call "columns"
@@ -4583,11 +4620,11 @@ void CLikeSourceEmitter::emitIRMatrixLayoutModifiers(VarLayout* layout)
switch (matrixTypeLayout->mode)
{
case kMatrixLayoutMode_ColumnMajor:
- m_stream->emit("layout(row_major)\n");
+ m_writer->emit("layout(row_major)\n");
break;
case kMatrixLayoutMode_RowMajor:
- m_stream->emit("layout(column_major)\n");
+ m_writer->emit("layout(column_major)\n");
break;
}
break;
@@ -4615,14 +4652,14 @@ void CLikeSourceEmitter::maybeEmitGLSLFlatModifier(IRType* valueType)
case kIROp_IntType:
case kIROp_UIntType:
case kIROp_UInt64Type:
- m_stream->emit("flat ");
+ m_writer->emit("flat ");
break;
}
}
void CLikeSourceEmitter::emitInterpolationModifiers(IRInst* varInst, IRType* valueType, VarLayout* layout)
{
- bool isGLSL = (getTarget() == CodeGenTarget::GLSL);
+ bool isGLSL = (getSourceStyle() == SourceStyle::GLSL);
bool anyModifiers = false;
for(auto dd : varInst->getDecorations())
@@ -4637,27 +4674,27 @@ void CLikeSourceEmitter::emitInterpolationModifiers(IRInst* varInst, IRType* val
{
case IRInterpolationMode::NoInterpolation:
anyModifiers = true;
- m_stream->emit(isGLSL ? "flat " : "nointerpolation ");
+ m_writer->emit(isGLSL ? "flat " : "nointerpolation ");
break;
case IRInterpolationMode::NoPerspective:
anyModifiers = true;
- m_stream->emit("noperspective ");
+ m_writer->emit("noperspective ");
break;
case IRInterpolationMode::Linear:
anyModifiers = true;
- m_stream->emit(isGLSL ? "smooth " : "linear ");
+ m_writer->emit(isGLSL ? "smooth " : "linear ");
break;
case IRInterpolationMode::Sample:
anyModifiers = true;
- m_stream->emit("sample ");
+ m_writer->emit("sample ");
break;
case IRInterpolationMode::Centroid:
anyModifiers = true;
- m_stream->emit("centroid ");
+ m_writer->emit("centroid ");
break;
default:
@@ -4691,7 +4728,7 @@ void CLikeSourceEmitter::emitInterpolationModifiers(IRInst* varInst, IRType* val
UInt CLikeSourceEmitter::getRayPayloadLocation(IRInst* inst)
{
- auto& map = m_context->mapIRValueToRayPayloadLocation;
+ auto& map = m_mapIRValueToRayPayloadLocation;
UInt value = 0;
if(map.TryGetValue(inst, value))
return value;
@@ -4703,7 +4740,7 @@ UInt CLikeSourceEmitter::getRayPayloadLocation(IRInst* inst)
UInt CLikeSourceEmitter::getCallablePayloadLocation(IRInst* inst)
{
- auto& map = m_context->mapIRValueToCallablePayloadLocation;
+ auto& map = m_mapIRValueToCallablePayloadLocation;
UInt value = 0;
if(map.TryGetValue(inst, value))
return value;
@@ -4742,9 +4779,9 @@ void CLikeSourceEmitter::emitGLSLImageFormatModifier(IRInst* var, IRTextureType*
// should emit a `layout` modifier using the GLSL name
// for the format.
//
- m_stream->emit("layout(");
- m_stream->emit(getGLSLNameForImageFormat(format));
- m_stream->emit(")\n");
+ m_writer->emit("layout(");
+ m_writer->emit(getGLSLNameForImageFormat(format));
+ m_writer->emit(")\n");
}
// No matter what, if an explicit `[format(...)]` was given,
@@ -4764,7 +4801,7 @@ void CLikeSourceEmitter::emitGLSLImageFormatModifier(IRInst* var, IRTextureType*
// treating images without explicit formats as having
// unknown format.
//
- if(this->m_context->compileRequest->useUnknownImageFormatAsDefault)
+ if(m_compileRequest->useUnknownImageFormatAsDefault)
{
requireGLSLExtension("GL_EXT_shader_image_load_formatted");
return;
@@ -4804,10 +4841,10 @@ void CLikeSourceEmitter::emitGLSLImageFormatModifier(IRInst* var, IRTextureType*
}
if(auto elementBasicType = as<IRBasicType>(elementType))
{
- m_stream->emit("layout(");
+ m_writer->emit("layout(");
switch(vectorWidth)
{
- default: m_stream->emit("rgba"); break;
+ default: m_writer->emit("rgba"); break;
case 3:
{
@@ -4828,21 +4865,21 @@ void CLikeSourceEmitter::emitGLSLImageFormatModifier(IRInst* var, IRTextureType*
// and add an attribute for specifying the format manually if you really want to override our
// inference (e.g., to specify r11fg11fb10f).
- m_stream->emit("rgba");
+ m_writer->emit("rgba");
//Emit("rgb");
break;
}
- case 2: m_stream->emit("rg"); break;
- case 1: m_stream->emit("r"); break;
+ case 2: m_writer->emit("rg"); break;
+ case 1: m_writer->emit("r"); break;
}
switch(elementBasicType->getBaseType())
{
default:
- case BaseType::Float: m_stream->emit("32f"); break;
- case BaseType::Half: m_stream->emit("16f"); break;
- case BaseType::UInt: m_stream->emit("32ui"); break;
- case BaseType::Int: m_stream->emit("32i"); break;
+ case BaseType::Float: m_writer->emit("32f"); break;
+ case BaseType::Half: m_writer->emit("16f"); break;
+ case BaseType::UInt: m_writer->emit("32ui"); break;
+ case BaseType::Int: m_writer->emit("32i"); break;
// TODO: Here are formats that are available in GLSL,
// but that are not handled by the above cases.
@@ -4879,7 +4916,7 @@ void CLikeSourceEmitter::emitGLSLImageFormatModifier(IRInst* var, IRTextureType*
// r16ui
// r8ui
}
- m_stream->emit(")\n");
+ m_writer->emit(")\n");
}
}
@@ -4888,7 +4925,7 @@ void CLikeSourceEmitter::emitIRTempModifiers(IRInst* temp)
{
if(temp->findDecoration<IRPreciseDecoration>())
{
- m_stream->emit("precise ");
+ m_writer->emit("precise ");
}
}
@@ -4901,37 +4938,37 @@ void CLikeSourceEmitter::emitIRVarModifiers(VarLayout* layout,IRInst* varDecl, I
//
if(varDecl->findDecoration<IRVulkanRayPayloadDecoration>())
{
- m_stream->emit("layout(location = ");
- m_stream->emit(getRayPayloadLocation(varDecl));
- m_stream->emit(")\n");
- m_stream->emit("rayPayloadNV\n");
+ m_writer->emit("layout(location = ");
+ m_writer->emit(getRayPayloadLocation(varDecl));
+ m_writer->emit(")\n");
+ m_writer->emit("rayPayloadNV\n");
}
if(varDecl->findDecoration<IRVulkanCallablePayloadDecoration>())
{
- m_stream->emit("layout(location = ");
- m_stream->emit(getCallablePayloadLocation(varDecl));
- m_stream->emit(")\n");
- m_stream->emit("callableDataNV\n");
+ m_writer->emit("layout(location = ");
+ m_writer->emit(getCallablePayloadLocation(varDecl));
+ m_writer->emit(")\n");
+ m_writer->emit("callableDataNV\n");
}
if(varDecl->findDecoration<IRVulkanHitAttributesDecoration>())
{
- m_stream->emit("hitAttributeNV\n");
+ m_writer->emit("hitAttributeNV\n");
}
if(varDecl->findDecoration<IRGloballyCoherentDecoration>())
{
- switch(getTarget())
+ switch(getSourceStyle())
{
default:
break;
- case CodeGenTarget::HLSL:
- m_stream->emit("globallycoherent\n");
+ case SourceStyle::HLSL:
+ m_writer->emit("globallycoherent\n");
break;
- case CodeGenTarget::GLSL:
- m_stream->emit("coherent\n");
+ case SourceStyle::GLSL:
+ m_writer->emit("coherent\n");
break;
}
}
@@ -4945,7 +4982,7 @@ void CLikeSourceEmitter::emitIRVarModifiers(VarLayout* layout,IRInst* varDecl, I
// As a special case, if we are emitting a GLSL declaration
// for an HLSL `RWTexture*` then we need to emit a `format` layout qualifier.
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
if(auto resourceType = as<IRTextureType>(unwrapArray(varType)))
{
@@ -4970,7 +5007,7 @@ void CLikeSourceEmitter::emitIRVarModifiers(VarLayout* layout,IRInst* varDecl, I
emitInterpolationModifiers(varDecl, varType, layout);
}
- if (getTarget() == CodeGenTarget::GLSL)
+ if (getSourceStyle() == SourceStyle::GLSL)
{
// Layout-related modifiers need to come before the declaration,
// so deal with them here.
@@ -4984,36 +5021,36 @@ void CLikeSourceEmitter::emitIRVarModifiers(VarLayout* layout,IRInst* varDecl, I
case LayoutResourceKind::Uniform:
case LayoutResourceKind::ShaderResource:
case LayoutResourceKind::DescriptorTableSlot:
- m_stream->emit("uniform ");
+ m_writer->emit("uniform ");
break;
case LayoutResourceKind::VaryingInput:
{
- m_stream->emit("in ");
+ m_writer->emit("in ");
}
break;
case LayoutResourceKind::VaryingOutput:
{
- m_stream->emit("out ");
+ m_writer->emit("out ");
}
break;
case LayoutResourceKind::RayPayload:
{
- m_stream->emit("rayPayloadInNV ");
+ m_writer->emit("rayPayloadInNV ");
}
break;
case LayoutResourceKind::CallablePayload:
{
- m_stream->emit("callableDataInNV ");
+ m_writer->emit("callableDataInNV ");
}
break;
case LayoutResourceKind::HitAttributes:
{
- m_stream->emit("hitAttributeNV ");
+ m_writer->emit("hitAttributeNV ");
}
break;
@@ -5030,13 +5067,13 @@ void CLikeSourceEmitter::emitHLSLParameterGroup(IRGlobalParam* varDecl, IRUnifor
{
if(as<IRTextureBufferType>(type))
{
- m_stream->emit("tbuffer ");
+ m_writer->emit("tbuffer ");
}
else
{
- m_stream->emit("cbuffer ");
+ m_writer->emit("cbuffer ");
}
- m_stream->emit(getIRName(varDecl));
+ m_writer->emit(getIRName(varDecl));
auto varLayout = getVarLayout(varDecl);
SLANG_RELEASE_ASSERT(varLayout);
@@ -5057,16 +5094,16 @@ void CLikeSourceEmitter::emitHLSLParameterGroup(IRGlobalParam* varDecl, IRUnifor
emitHLSLRegisterSemantic(LayoutResourceKind::ConstantBuffer, &containerChain);
- m_stream->emit("\n{\n");
- m_stream->indent();
+ m_writer->emit("\n{\n");
+ m_writer->indent();
auto elementType = type->getElementType();
emitIRType(elementType, getIRName(varDecl));
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
- m_stream->dedent();
- m_stream->emit("}\n");
+ m_writer->dedent();
+ m_writer->emit("}\n");
}
void CLikeSourceEmitter::emitArrayBrackets(IRType* inType)
@@ -5092,9 +5129,9 @@ void CLikeSourceEmitter::emitArrayBrackets(IRType* inType)
{
if(auto arrayType = as<IRArrayType>(type))
{
- m_stream->emit("[");
+ m_writer->emit("[");
emitVal(arrayType->getElementCount(), getInfo(EmitOp::General));
- m_stream->emit("]");
+ m_writer->emit("]");
// Continue looping on the next layer in.
//
@@ -5102,7 +5139,7 @@ void CLikeSourceEmitter::emitArrayBrackets(IRType* inType)
}
else if(auto unsizedArrayType = as<IRUnsizedArrayType>(type))
{
- m_stream->emit("[]");
+ m_writer->emit("[]");
// Continue looping on the next layer in.
//
@@ -5153,53 +5190,53 @@ void CLikeSourceEmitter::emitGLSLParameterGroup(IRGlobalParam* varDecl, IRUnifor
{
// TODO: A shader record in vk can be potentially read-write. Currently slang doesn't support write access
// and readonly buffer generates SPIRV validation error.
- m_stream->emit("buffer ");
+ m_writer->emit("buffer ");
}
else if(as<IRGLSLShaderStorageBufferType>(type))
{
// Is writable
- m_stream->emit("layout(std430) buffer ");
+ m_writer->emit("layout(std430) buffer ");
}
// TODO: what to do with HLSL `tbuffer` style buffers?
else
{
// uniform is implicitly read only
- m_stream->emit("layout(std140) uniform ");
+ m_writer->emit("layout(std140) uniform ");
}
// Generate a dummy name for the block
- m_stream->emit("_S");
- m_stream->emit(m_context->uniqueIDCounter++);
+ m_writer->emit("_S");
+ m_writer->emit(m_uniqueIDCounter++);
- m_stream->emit("\n{\n");
- m_stream->indent();
+ m_writer->emit("\n{\n");
+ m_writer->indent();
auto elementType = type->getElementType();
emitIRType(elementType, "_data");
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
- m_stream->dedent();
- m_stream->emit("} ");
+ m_writer->dedent();
+ m_writer->emit("} ");
- m_stream->emit(getIRName(varDecl));
+ m_writer->emit(getIRName(varDecl));
// If the underlying variable was an array (or array of arrays, etc.)
// we need to emit all those array brackets here.
emitArrayBrackets(varDecl->getDataType());
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
void CLikeSourceEmitter::emitIRParameterGroup(IRGlobalParam* varDecl, IRUniformParameterGroupType* type)
{
- switch (getTarget())
+ switch (getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
emitHLSLParameterGroup(varDecl, type);
break;
- case CodeGenTarget::GLSL:
+ case SourceStyle::GLSL:
emitGLSLParameterGroup(varDecl, type);
break;
}
@@ -5249,7 +5286,7 @@ void CLikeSourceEmitter::emitIRVar(IRVar* varDecl)
emitIRLayoutSemantics(varDecl);
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
void CLikeSourceEmitter::emitIRStructuredBuffer_GLSL(IRGlobalParam* varDecl, IRHLSLStructuredBufferTypeBase* structuredBufferType)
@@ -5259,7 +5296,7 @@ void CLikeSourceEmitter::emitIRStructuredBuffer_GLSL(IRGlobalParam* varDecl, IRH
// TODO: we should require either the extension or the version...
requireGLSLVersion(430);
- m_stream->emit("layout(std430");
+ m_writer->emit("layout(std430");
auto layout = getVarLayout(varDecl);
if (layout)
@@ -5270,16 +5307,16 @@ void CLikeSourceEmitter::emitIRStructuredBuffer_GLSL(IRGlobalParam* varDecl, IRH
const UInt index = getBindingOffset(&chain, kind);
const UInt space = getBindingSpace(&chain, kind);
- m_stream->emit(", binding = ");
- m_stream->emit(index);
+ m_writer->emit(", binding = ");
+ m_writer->emit(index);
if (space)
{
- m_stream->emit(", set = ");
- m_stream->emit(space);
+ m_writer->emit(", set = ");
+ m_writer->emit(space);
}
}
- m_stream->emit(") ");
+ m_writer->emit(") ");
/*
If the output type is a buffer, and we can determine it is only readonly we can prefix before
@@ -5296,30 +5333,30 @@ void CLikeSourceEmitter::emitIRStructuredBuffer_GLSL(IRGlobalParam* varDecl, IRH
if (as<IRHLSLStructuredBufferType>(structuredBufferType))
{
- m_stream->emit("readonly ");
+ m_writer->emit("readonly ");
}
- m_stream->emit("buffer ");
+ m_writer->emit("buffer ");
// Generate a dummy name for the block
- m_stream->emit("_S");
- m_stream->emit(m_context->uniqueIDCounter++);
+ m_writer->emit("_S");
+ m_writer->emit(m_uniqueIDCounter++);
- m_stream->emit(" {\n");
- m_stream->indent();
+ m_writer->emit(" {\n");
+ m_writer->indent();
auto elementType = structuredBufferType->getElementType();
emitIRType(elementType, "_data[]");
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
- m_stream->dedent();
- m_stream->emit("} ");
+ m_writer->dedent();
+ m_writer->emit("} ");
- m_stream->emit(getIRName(varDecl));
+ m_writer->emit(getIRName(varDecl));
emitArrayBrackets(varDecl->getDataType());
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
void CLikeSourceEmitter::emitIRByteAddressBuffer_GLSL(IRGlobalParam* varDecl, IRByteAddressBufferTypeBase* byteAddressBufferType)
@@ -5333,7 +5370,7 @@ void CLikeSourceEmitter::emitIRByteAddressBuffer_GLSL(IRGlobalParam* varDecl, IR
// TODO: we should require either the extension or the version...
requireGLSLVersion(430);
- m_stream->emit("layout(std430");
+ m_writer->emit("layout(std430");
auto layout = getVarLayout(varDecl);
if (layout)
@@ -5344,16 +5381,16 @@ void CLikeSourceEmitter::emitIRByteAddressBuffer_GLSL(IRGlobalParam* varDecl, IR
const UInt index = getBindingOffset(&chain, kind);
const UInt space = getBindingSpace(&chain, kind);
- m_stream->emit(", binding = ");
- m_stream-> emit(index);
+ m_writer->emit(", binding = ");
+ m_writer-> emit(index);
if (space)
{
- m_stream->emit(", set = ");
- m_stream->emit(space);
+ m_writer->emit(", set = ");
+ m_writer->emit(space);
}
}
- m_stream->emit(") ");
+ m_writer->emit(") ");
/*
If the output type is a buffer, and we can determine it is only readonly we can prefix before
@@ -5366,26 +5403,26 @@ void CLikeSourceEmitter::emitIRByteAddressBuffer_GLSL(IRGlobalParam* varDecl, IR
if (as<IRHLSLByteAddressBufferType>(byteAddressBufferType))
{
- m_stream->emit("readonly ");
+ m_writer->emit("readonly ");
}
- m_stream->emit("buffer ");
+ m_writer->emit("buffer ");
// Generate a dummy name for the block
- m_stream->emit("_S");
- m_stream->emit(m_context->uniqueIDCounter++);
- m_stream->emit("\n{\n");
- m_stream->indent();
+ m_writer->emit("_S");
+ m_writer->emit(m_uniqueIDCounter++);
+ m_writer->emit("\n{\n");
+ m_writer->indent();
- m_stream->emit("uint _data[];\n");
+ m_writer->emit("uint _data[];\n");
- m_stream->dedent();
- m_stream->emit("} ");
+ m_writer->dedent();
+ m_writer->emit("} ");
- m_stream->emit(getIRName(varDecl));
+ m_writer->emit(getIRName(varDecl));
emitArrayBrackets(varDecl->getDataType());
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
void CLikeSourceEmitter::emitIRGlobalVar(IRGlobalVar* varDecl)
@@ -5404,13 +5441,13 @@ void CLikeSourceEmitter::emitIRGlobalVar(IRGlobalVar* varDecl)
initFuncName = getIRName(varDecl);
initFuncName.append("_init");
- m_stream->emit("\n");
+ m_writer->emit("\n");
emitIRType(varType, initFuncName);
- m_stream->emit("()\n{\n");
- m_stream->indent();
+ m_writer->emit("()\n{\n");
+ m_writer->indent();
emitIRFunctionBody(varDecl);
- m_stream->dedent();
- m_stream->emit("}\n");
+ m_writer->dedent();
+ m_writer->emit("}\n");
}
// An ordinary global variable won't have a layout
@@ -5424,13 +5461,13 @@ void CLikeSourceEmitter::emitIRGlobalVar(IRGlobalVar* varDecl)
// shader parameter) may need special
// modifiers to indicate it as such.
//
- switch (getTarget())
+ switch (getSourceStyle())
{
- case CodeGenTarget::HLSL:
+ case SourceStyle::HLSL:
// HLSL requires the `static` modifier on any
// global variables; otherwise they are assumed
// to be uniforms.
- m_stream->emit("static ");
+ m_writer->emit("static ");
break;
default:
@@ -5450,12 +5487,12 @@ void CLikeSourceEmitter::emitIRGlobalVar(IRGlobalVar* varDecl)
if (varDecl->getFirstBlock())
{
- m_stream->emit(" = ");
- m_stream->emit(initFuncName);
- m_stream->emit("()");
+ m_writer->emit(" = ");
+ m_writer->emit(initFuncName);
+ m_writer->emit("()");
}
- m_stream->emit(";\n\n");
+ m_writer->emit(";\n\n");
}
void CLikeSourceEmitter::emitIRGlobalParam(IRGlobalParam* varDecl)
@@ -5486,7 +5523,7 @@ void CLikeSourceEmitter::emitIRGlobalParam(IRGlobalParam* varDecl)
return;
}
- if(getTarget() == CodeGenTarget::GLSL)
+ if(getSourceStyle() == SourceStyle::GLSL)
{
// There are a number of types that are (or can be)
// "first-class" in D3D HLSL, but are second-class in GLSL in
@@ -5586,7 +5623,7 @@ void CLikeSourceEmitter::emitIRGlobalParam(IRGlobalParam* varDecl)
// A shader parameter cannot have an initializer,
// so we do need to consider emitting one here.
- m_stream->emit(";\n\n");
+ m_writer->emit(";\n\n");
}
@@ -5619,11 +5656,11 @@ void CLikeSourceEmitter::emitIRGlobalConstant(IRGlobalConstant* valDecl)
{
auto valType = valDecl->getDataType();
- if( getTarget() != CodeGenTarget::GLSL )
+ if( getSourceStyle() != SourceStyle::GLSL )
{
- m_stream->emit("static ");
+ m_writer->emit("static ");
}
- m_stream->emit("const ");
+ m_writer->emit("const ");
emitIRRateQualifiers(valDecl);
emitIRType(valType, getIRName(valDecl));
@@ -5632,7 +5669,7 @@ void CLikeSourceEmitter::emitIRGlobalConstant(IRGlobalConstant* valDecl)
// There is an initializer (which we expect for
// any global constant...).
- m_stream->emit(" = ");
+ m_writer->emit(" = ");
// We need to emit the entire initializer as
// a single expression.
@@ -5640,12 +5677,12 @@ void CLikeSourceEmitter::emitIRGlobalConstant(IRGlobalConstant* valDecl)
}
- m_stream->emit(";\n");
+ m_writer->emit(";\n");
}
void CLikeSourceEmitter::emitIRGlobalInst(IRInst* inst)
{
- m_stream->advanceToSourceLocation(inst->sourceLoc);
+ m_writer->advanceToSourceLocation(inst->sourceLoc);
switch(inst->op)
{
diff --git a/source/slang/slang-c-like-source-emitter.h b/source/slang/slang-emit-c-like.h
index 4fcbb0b1c..f74850b35 100644
--- a/source/slang/slang-c-like-source-emitter.h
+++ b/source/slang/slang-emit-c-like.h
@@ -1,14 +1,14 @@
-// slang-c-like-source-emitter.h
-#ifndef SLANG_C_LIKE_SOURCE_EMITTER_H_INCLUDED
-#define SLANG_C_LIKE_SOURCE_EMITTER_H_INCLUDED
+// slang-emit-c-like.h
+#ifndef SLANG_EMIT_C_LIKE_H
+#define SLANG_EMIT_C_LIKE_H
#include "../core/slang-basic.h"
#include "slang-compiler.h"
-#include "slang-emit-context.h"
-#include "slang-extension-usage-tracker.h"
+#include "slang-emit-glsl-extension-tracker.h"
#include "slang-emit-precedence.h"
+#include "slang-emit-source-writer.h"
#include "slang-ir.h"
#include "slang-ir-insts.h"
@@ -17,8 +17,43 @@
namespace Slang
{
-struct CLikeSourceEmitter
+class CLikeSourceEmitter
{
+public:
+ struct CInfo
+ {
+ BackEndCompileRequest* compileRequest = nullptr;
+ // The target language we want to generate code for
+ CodeGenTarget target = CodeGenTarget::Unknown;
+ // The entry point we are being asked to compile
+ EntryPoint* entryPoint = nullptr;
+ // The "effective" profile that is being used to emit code,
+ // combining information from the target and entry point.
+ Profile effectiveProfile = Profile::RawEnum::Unknown;
+
+ SourceWriter* sourceWriter = nullptr;
+ // The layout for the entry point
+ EntryPointLayout* entryPointLayout = nullptr;
+
+ ProgramLayout* programLayout = nullptr;
+ // We track the original global-scope layout so that we can
+ // find layout information for `import`ed parameters.
+ //
+ // TODO: This will probably change if we represent imports
+ // explicitly in the layout data.
+ StructTypeLayout* globalStructLayout = nullptr;
+ };
+
+ /// To simplify cases
+ enum class SourceStyle
+ {
+ Unknown,
+ GLSL,
+ HLSL,
+ C,
+ CPP,
+ CountOf,
+ };
enum class BuiltInCOp
{
Splat, //< Splat a single value to all values of a vector or matrix type
@@ -58,13 +93,23 @@ struct CLikeSourceEmitter
};
/// Ctor
- CLikeSourceEmitter(EmitContext* context);
-
+ CLikeSourceEmitter(const CInfo& cinfo);
+
/// Get the source manager
- SourceManager* getSourceManager() { return m_context->getSourceManager(); }
+ SourceManager* getSourceManager() { return m_compileRequest->getSourceManager(); }
/// Get the diagnostic sink
- DiagnosticSink* getSink() { return m_context->getSink();}
+ DiagnosticSink* getSink() { return m_compileRequest->getSink();}
+ LineDirectiveMode getLineDirectiveMode() { return m_compileRequest->getLineDirectiveMode(); }
+
+ /// Get the code gen target
+ CodeGenTarget getTarget() { return m_target; }
+ /// Get the source style
+ SLANG_FORCE_INLINE SourceStyle getSourceStyle() const { return m_sourceStyle; }
+
+ void noteInternalErrorLoc(SourceLoc loc) { return getSink()->noteInternalErrorLoc(loc); }
+
+ GLSLExtensionTracker* getGLSLExtensionTracker() { return &m_glslExtensionTracker; }
//
// Types
@@ -91,24 +136,12 @@ struct CLikeSourceEmitter
void emitVectorTypeName(IRType* elementType, IRIntegerValue elementCount);
- void emitVectorTypeImpl(IRVectorType* vecType);
-
- void emitMatrixTypeImpl(IRMatrixType* matType);
-
void emitSamplerStateType(IRSamplerStateTypeBase* samplerStateType);
void emitStructuredBufferType(IRHLSLStructuredBufferTypeBase* type);
void emitUntypedBufferType(IRUntypedBufferResourceType* type);
- void emitSimpleTypeImpl(IRType* type);
-
- void emitArrayTypeImpl(IRArrayType* arrayType, EDeclarator* declarator);
-
- void emitUnsizedArrayTypeImpl(IRUnsizedArrayType* arrayType, EDeclarator* declarator);
-
- void emitTypeImpl(IRType* type, EDeclarator* declarator);
-
void emitType(IRType* type, const SourceLoc& typeLoc, Name* name, const SourceLoc& nameLoc);
void emitType(IRType* type, Name* name);
void emitType(IRType* type, String const& name);
@@ -185,9 +218,7 @@ struct CLikeSourceEmitter
void emitDeclarator(IRDeclaratorInfo* declarator);
void emitIRSimpleValue(IRInst* inst);
-
- CodeGenTarget getTarget();
-
+
bool shouldFoldIRInstIntoUseSites(IRInst* inst, IREmitMode mode);
void emitIROperand(IRInst* inst, IREmitMode mode, EmitOpInfo const& outerPrec);
@@ -238,8 +269,6 @@ struct CLikeSourceEmitter
void emitIRInst(IRInst* inst, IREmitMode mode);
- void emitIRInstImpl(IRInst* inst, IREmitMode mode);
-
void emitIRSemantics(VarLayout* varLayout);
void emitIRSemantics(IRInst* inst);
@@ -362,8 +391,19 @@ struct CLikeSourceEmitter
void executeIREmitActions(List<EmitAction> const& actions);
void emitIRModule(IRModule* module);
+ /// Gets a source style for a target. Returns Unknown if not a known target
+ static SourceStyle getSourceStyle(CodeGenTarget target);
+
protected:
+ void _emitSimpleType(IRType* type);
+ void _emitArrayType(IRArrayType* arrayType, EDeclarator* declarator);
+ void _emitUnsizedArrayType(IRUnsizedArrayType* arrayType, EDeclarator* declarator);
+ void _emitType(IRType* type, EDeclarator* declarator);
+ void _emitIRInst(IRInst* inst, IREmitMode mode);
+ void _emitVectorType(IRVectorType* vecType);
+ void _emitMatrixType(IRMatrixType* matType);
+
void _requireHalf();
void _emitCVecType(IROp op, Int size);
void _emitCMatType(IROp op, IRIntegerValue rowCount, IRIntegerValue colCount);
@@ -371,8 +411,62 @@ struct CLikeSourceEmitter
void _emitCFunc(BuiltInCOp cop, IRType* type);
void _maybeEmitGLSLCast(IRType* castType, IRInst* inst, IREmitMode mode);
- EmitContext* m_context;
- SourceStream* m_stream;
+
+ BackEndCompileRequest* m_compileRequest = nullptr;
+
+ // The entry point we are being asked to compile
+ EntryPoint* m_entryPoint;
+
+ // The layout for the entry point
+ EntryPointLayout* m_entryPointLayout;
+
+ // The target language we want to generate code for
+ CodeGenTarget m_target;
+ // Source style - a simplification of the more nuanced m_target
+ SourceStyle m_sourceStyle;
+
+ // Where source is written to
+ SourceWriter* m_writer;
+
+ // We only want to emit each `import`ed module one time, so
+ // we maintain a set of already-emitted modules.
+ HashSet<ModuleDecl*> m_modulesAlreadyEmitted;
+
+ // We track the original global-scope layout so that we can
+ // find layout information for `import`ed parameters.
+ //
+ // TODO: This will probably change if we represent imports
+ // explicitly in the layout data.
+ StructTypeLayout* m_globalStructLayout;
+
+ ProgramLayout* m_programLayout;
+
+ ModuleDecl* m_program;
+
+ GLSLExtensionTracker m_glslExtensionTracker;
+
+ UInt m_uniqueIDCounter = 1;
+ Dictionary<IRInst*, UInt> m_mapIRValueToID;
+ Dictionary<Decl*, UInt> m_mapDeclToID;
+
+ HashSet<String> m_irDeclsVisited;
+
+ HashSet<String> m_irTupleTypes;
+
+ // The "effective" profile that is being used to emit code,
+ // combining information from the target and entry point.
+ Profile m_effectiveProfile;
+
+ // Map a string name to the number of times we have seen this
+ // name used so far during code emission.
+ Dictionary<String, UInt> m_uniqueNameCounters;
+
+ // Map an IR instruction to the name that we've decided
+ // to use for it when emitting code.
+ Dictionary<IRInst*, String> m_mapInstToName;
+
+ Dictionary<IRInst*, UInt> m_mapIRValueToRayPayloadLocation;
+ Dictionary<IRInst*, UInt> m_mapIRValueToCallablePayloadLocation;
};
}
diff --git a/source/slang/slang-emit-context.cpp b/source/slang/slang-emit-context.cpp
deleted file mode 100644
index b330b86f9..000000000
--- a/source/slang/slang-emit-context.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// slang-emit-context.cpp
-#include "slang-emit-context.h"
-
-namespace Slang {
-
-
-} // namespace Slang
diff --git a/source/slang/slang-emit-context.h b/source/slang/slang-emit-context.h
deleted file mode 100644
index 337d0434f..000000000
--- a/source/slang/slang-emit-context.h
+++ /dev/null
@@ -1,79 +0,0 @@
-// slang-emit-context.h
-#ifndef SLANG_EMIT_CONTEXT_H_INCLUDED
-#define SLANG_EMIT_CONTEXT_H_INCLUDED
-
-#include "../core/slang-basic.h"
-
-#include "slang-compiler.h"
-#include "slang-type-layout.h"
-#include "slang-source-stream.h"
-#include "slang-extension-usage-tracker.h"
-
-namespace Slang
-{
-
-// Shared state for an entire emit session
-struct EmitContext
-{
- DiagnosticSink* getSink() { return compileRequest->getSink(); }
- LineDirectiveMode getLineDirectiveMode() { return compileRequest->getLineDirectiveMode(); }
- SourceManager* getSourceManager() { return compileRequest->getSourceManager(); }
- void noteInternalErrorLoc(SourceLoc loc) { return getSink()->noteInternalErrorLoc(loc); }
-
- BackEndCompileRequest* compileRequest = nullptr;
-
- // The entry point we are being asked to compile
- EntryPoint* entryPoint;
-
- // The layout for the entry point
- EntryPointLayout* entryPointLayout;
-
- // The target language we want to generate code for
- CodeGenTarget target;
-
- // Where source is written to
- SourceStream* stream;
-
- // We only want to emit each `import`ed module one time, so
- // we maintain a set of already-emitted modules.
- HashSet<ModuleDecl*> modulesAlreadyEmitted;
-
- // We track the original global-scope layout so that we can
- // find layout information for `import`ed parameters.
- //
- // TODO: This will probably change if we represent imports
- // explicitly in the layout data.
- StructTypeLayout* globalStructLayout;
-
- ProgramLayout* programLayout;
-
- ModuleDecl* program;
-
- ExtensionUsageTracker extensionUsageTracker;
-
- UInt uniqueIDCounter = 1;
- Dictionary<IRInst*, UInt> mapIRValueToID;
- Dictionary<Decl*, UInt> mapDeclToID;
-
- HashSet<String> irDeclsVisited;
-
- HashSet<String> irTupleTypes;
-
- // The "effective" profile that is being used to emit code,
- // combining information from the target and entry point.
- Profile effectiveProfile;
-
- // Map a string name to the number of times we have seen this
- // name used so far during code emission.
- Dictionary<String, UInt> uniqueNameCounters;
-
- // Map an IR instruction to the name that we've decided
- // to use for it when emitting code.
- Dictionary<IRInst*, String> mapInstToName;
-
- Dictionary<IRInst*, UInt> mapIRValueToRayPayloadLocation;
- Dictionary<IRInst*, UInt> mapIRValueToCallablePayloadLocation;
-};
-
-}
-#endif
diff --git a/source/slang/slang-emit-glsl-extension-tracker.cpp b/source/slang/slang-emit-glsl-extension-tracker.cpp
new file mode 100644
index 000000000..c162f2f46
--- /dev/null
+++ b/source/slang/slang-emit-glsl-extension-tracker.cpp
@@ -0,0 +1,44 @@
+// slang-emit-glsl-extension-tracker.cpp
+#include "slang-emit-glsl-extension-tracker.h"
+
+namespace Slang {
+
+void GLSLExtensionTracker::requireExtension(const String& name)
+{
+ if (m_extensionsRequired.Contains(name))
+ return;
+
+ StringBuilder& sb = m_extensionRequireLines;
+
+ sb.append("#extension ");
+ sb.append(name);
+ sb.append(" : require\n");
+
+ m_extensionsRequired.Add(name);
+}
+
+void GLSLExtensionTracker::requireVersion(ProfileVersion version)
+{
+ // Check if this profile is newer
+ if ((UInt)version > (UInt)m_profileVersion)
+ {
+ m_profileVersion = version;
+ }
+}
+
+void GLSLExtensionTracker::requireHalfExtension()
+{
+ if (!m_hasHalfExtension)
+ {
+ // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_16bit_storage.txt
+ requireExtension("GL_EXT_shader_16bit_storage");
+
+ // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_explicit_arithmetic_types.txt
+ requireExtension("GL_EXT_shader_explicit_arithmetic_types");
+
+ m_hasHalfExtension = true;
+ }
+}
+
+
+} // namespace Slang
diff --git a/source/slang/slang-emit-glsl-extension-tracker.h b/source/slang/slang-emit-glsl-extension-tracker.h
new file mode 100644
index 000000000..3ba226fbc
--- /dev/null
+++ b/source/slang/slang-emit-glsl-extension-tracker.h
@@ -0,0 +1,34 @@
+// slang-emit-glsl-extension-tracker.h
+#ifndef SLANG_EMIT_GLSL_EXTENSION_TRACKER_H
+#define SLANG_EMIT_GLSL_EXTENSION_TRACKER_H
+
+#include "../core/slang-basic.h"
+
+#include "slang-compiler.h"
+
+namespace Slang
+{
+
+class GLSLExtensionTracker
+{
+public:
+
+ void requireExtension(const String& name);
+ void requireVersion(ProfileVersion version);
+ void requireHalfExtension();
+
+ ProfileVersion getRequiredProfileVersion() const { return m_profileVersion; }
+ const StringBuilder& getExtensionRequireLines() const { return m_extensionRequireLines; }
+
+protected:
+ // Record the GLSL extensions we have already emitted a `#extension` for
+ HashSet<String> m_extensionsRequired;
+ StringBuilder m_extensionRequireLines;
+
+ ProfileVersion m_profileVersion = ProfileVersion::GLSL_110;
+
+ bool m_hasHalfExtension = false;
+};
+
+}
+#endif
diff --git a/source/slang/slang-source-stream.cpp b/source/slang/slang-emit-source-writer.cpp
index e561176ae..051e1ba0b 100644
--- a/source/slang/slang-source-stream.cpp
+++ b/source/slang/slang-emit-source-writer.cpp
@@ -1,5 +1,5 @@
-// emit.cpp
-#include "slang-source-stream.h"
+// slang-emit-source-writer.cpp
+#include "slang-emit-source-writer.h"
// Disable warnings about sprintf
#ifdef _WIN32
@@ -16,32 +16,32 @@
namespace Slang {
-SourceStream::SourceStream(SourceManager* sourceManager, LineDirectiveMode lineDirectiveMode)
+SourceWriter::SourceWriter(SourceManager* sourceManager, LineDirectiveMode lineDirectiveMode)
{
m_lineDirectiveMode = lineDirectiveMode;
this->m_sourceManager = sourceManager;
}
-String SourceStream::getContentAndClear()
+String SourceWriter::getContentAndClear()
{
String content(getContent());
clearContent();
return content;
}
-void SourceStream::emitRawTextSpan(char const* textBegin, char const* textEnd)
+void SourceWriter::emitRawTextSpan(char const* textBegin, char const* textEnd)
{
// TODO(tfoley): Need to make "corelib" not use `int` for pointer-sized things...
auto len = textEnd - textBegin;
m_builder.Append(textBegin, len);
}
-void SourceStream::emitRawText(char const* text)
+void SourceWriter::emitRawText(char const* text)
{
emitRawTextSpan(text, text + strlen(text));
}
-void SourceStream::_emitTextSpan(char const* textBegin, char const* textEnd)
+void SourceWriter::_emitTextSpan(char const* textBegin, char const* textEnd)
{
// Don't change anything given an empty string
if (textBegin == textEnd)
@@ -85,17 +85,17 @@ void SourceStream::_emitTextSpan(char const* textBegin, char const* textEnd)
m_loc.column += len;
}
-void SourceStream::indent()
+void SourceWriter::indent()
{
m_indentLevel++;
}
-void SourceStream::dedent()
+void SourceWriter::dedent()
{
m_indentLevel--;
}
-void SourceStream::emit(char const* textBegin, char const* textEnd)
+void SourceWriter::emit(char const* textBegin, char const* textEnd)
{
char const* spanBegin = textBegin;
char const* spanEnd = spanBegin;
@@ -125,70 +125,70 @@ void SourceStream::emit(char const* textBegin, char const* textEnd)
}
}
-void SourceStream::emit(char const* text)
+void SourceWriter::emit(char const* text)
{
emit(text, text + strlen(text));
}
-void SourceStream::emit(const String& text)
+void SourceWriter::emit(const String& text)
{
emit(text.begin(), text.end());
}
-void SourceStream::emit(const UnownedStringSlice& text)
+void SourceWriter::emit(const UnownedStringSlice& text)
{
emit(text.begin(), text.end());
}
-void SourceStream::emit(Name* name)
+void SourceWriter::emit(Name* name)
{
emit(getText(name));
}
-void SourceStream::emit(const NameLoc& nameAndLoc)
+void SourceWriter::emit(const NameLoc& nameAndLoc)
{
advanceToSourceLocation(nameAndLoc.loc);
emit(getText(nameAndLoc.name));
}
-void SourceStream::emitName(Name* name, const SourceLoc& locIn)
+void SourceWriter::emitName(Name* name, const SourceLoc& locIn)
{
advanceToSourceLocation(locIn);
emit(name);
}
-void SourceStream::emitName(const NameLoc& nameAndLoc)
+void SourceWriter::emitName(const NameLoc& nameAndLoc)
{
emitName(nameAndLoc.name, nameAndLoc.loc);
}
-void SourceStream::emitName(Name* name)
+void SourceWriter::emitName(Name* name)
{
emitName(name, SourceLoc());
}
-void SourceStream::emit(IntegerLiteralValue value)
+void SourceWriter::emit(IntegerLiteralValue value)
{
char buffer[32];
sprintf(buffer, "%lld", (long long int)value);
emit(buffer);
}
-void SourceStream::emit(UInt value)
+void SourceWriter::emit(UInt value)
{
char buffer[32];
sprintf(buffer, "%llu", (unsigned long long)(value));
emit(buffer);
}
-void SourceStream::emit(int value)
+void SourceWriter::emit(int value)
{
char buffer[16];
sprintf(buffer, "%d", value);
emit(buffer);
}
-void SourceStream::emit(double value)
+void SourceWriter::emit(double value)
{
// There are a few different requirements here that we need to deal with:
//
@@ -221,12 +221,12 @@ void SourceStream::emit(double value)
emit(stream.str().c_str());
}
-void SourceStream::advanceToSourceLocation(const SourceLoc& sourceLocation)
+void SourceWriter::advanceToSourceLocation(const SourceLoc& sourceLocation)
{
advanceToSourceLocation(getSourceManager()->getHumaneLoc(sourceLocation));
}
-void SourceStream::advanceToSourceLocation(const HumaneSourceLoc& sourceLocation)
+void SourceWriter::advanceToSourceLocation(const HumaneSourceLoc& sourceLocation)
{
// Skip invalid locations
if (sourceLocation.line <= 0)
@@ -236,7 +236,7 @@ void SourceStream::advanceToSourceLocation(const HumaneSourceLoc& sourceLocation
m_nextSourceLocation = sourceLocation;
}
-void SourceStream::_flushSourceLocationChange()
+void SourceWriter::_flushSourceLocationChange()
{
if (!m_needToUpdateSourceLocation)
return;
@@ -249,7 +249,7 @@ void SourceStream::_flushSourceLocationChange()
_emitLineDirectiveIfNeeded(m_nextSourceLocation);
}
-void SourceStream::_emitLineDirectiveAndUpdateSourceLocation(const HumaneSourceLoc& sourceLocation)
+void SourceWriter::_emitLineDirectiveAndUpdateSourceLocation(const HumaneSourceLoc& sourceLocation)
{
_emitLineDirective(sourceLocation);
@@ -259,7 +259,7 @@ void SourceStream::_emitLineDirectiveAndUpdateSourceLocation(const HumaneSourceL
m_loc = newLoc;
}
-void SourceStream::_emitLineDirectiveIfNeeded(const HumaneSourceLoc& sourceLocation)
+void SourceWriter::_emitLineDirectiveIfNeeded(const HumaneSourceLoc& sourceLocation)
{
// Don't do any of this work if the user has requested that we
// not emit line directives.
@@ -309,7 +309,7 @@ void SourceStream::_emitLineDirectiveIfNeeded(const HumaneSourceLoc& sourceLocat
}
}
-void SourceStream::_emitLineDirective(const HumaneSourceLoc& sourceLocation)
+void SourceWriter::_emitLineDirective(const HumaneSourceLoc& sourceLocation)
{
emitRawText("\n#line ");
diff --git a/source/slang/slang-source-stream.h b/source/slang/slang-emit-source-writer.h
index e6b7507c0..4d18ea8fe 100644
--- a/source/slang/slang-source-stream.h
+++ b/source/slang/slang-emit-source-writer.h
@@ -1,6 +1,6 @@
// slang-source-stream.h
-#ifndef SLANG_SOURCE_STREAM_H_INCLUDED
-#define SLANG_SOURCE_STREAM_H_INCLUDED
+#ifndef SLANG_EMIT_SOURCE_WRITER_H
+#define SLANG_EMIT_SOURCE_WRITER_H
#include "../core/slang-basic.h"
@@ -15,7 +15,7 @@ namespace Slang
* output line directives
+ Supports GLSL as well as C/CPP/HLSL style directives
* Support for line indention */
-class SourceStream
+class SourceWriter
{
public:
/// Emits without span without any extra processing
@@ -61,7 +61,7 @@ public:
SourceManager* getSourceManager() const { return m_sourceManager; }
/// Ctor
- SourceStream(SourceManager* sourceManager, LineDirectiveMode lineDirectiveMode);
+ SourceWriter(SourceManager* sourceManager, LineDirectiveMode lineDirectiveMode);
protected:
void _emitTextSpan(char const* textBegin, char const* textEnd);
diff --git a/source/slang/slang-emit.cpp b/source/slang/slang-emit.cpp
index 67b57660a..3cacb2d90 100644
--- a/source/slang/slang-emit.cpp
+++ b/source/slang/slang-emit.cpp
@@ -23,10 +23,9 @@
#include "slang-type-layout.h"
#include "slang-visitor.h"
-#include "slang-source-stream.h"
-#include "slang-emit-context.h"
+#include "slang-emit-source-writer.h"
-#include "slang-c-like-source-emitter.h"
+#include "slang-emit-c-like.h"
#include <assert.h>
@@ -172,32 +171,31 @@ String emitEntryPoint(
lineDirectiveMode = LineDirectiveMode::GLSL;
}
- SourceStream sourceStream(compileRequest->getSourceManager(), lineDirectiveMode );
+ SourceWriter sourceWriter(compileRequest->getSourceManager(), lineDirectiveMode );
- EmitContext emitContext;
- emitContext.compileRequest = compileRequest;
- emitContext.target = target;
- emitContext.entryPoint = entryPoint;
- emitContext.effectiveProfile = getEffectiveProfile(entryPoint, targetRequest);
- emitContext.stream = &sourceStream;
+ CLikeSourceEmitter::CInfo cinfo;
+
+ cinfo.compileRequest = compileRequest;
+ cinfo.target = target;
+ cinfo.entryPoint = entryPoint;
+ cinfo.effectiveProfile = getEffectiveProfile(entryPoint, targetRequest);
+ cinfo.sourceWriter = &sourceWriter;
if (entryPoint && programLayout)
{
- emitContext.entryPointLayout = findEntryPointLayout(
- programLayout,
- entryPoint);
+ cinfo.entryPointLayout = findEntryPointLayout(programLayout, entryPoint);
}
- emitContext.programLayout = programLayout;
+ cinfo.programLayout = programLayout;
// Layout information for the global scope is either an ordinary
// `struct` in the common case, or a constant buffer in the case
// where there were global-scope uniforms.
StructTypeLayout* globalStructLayout = programLayout ? getGlobalStructLayout(programLayout) : nullptr;
- emitContext.globalStructLayout = globalStructLayout;
+ cinfo.globalStructLayout = globalStructLayout;
- CLikeSourceEmitter sourceEmitter(&emitContext);
+ CLikeSourceEmitter sourceEmitter(cinfo);
{
auto session = targetRequest->getSession();
@@ -423,7 +421,7 @@ String emitEntryPoint(
irModule,
irEntryPoint,
compileRequest->getSink(),
- &emitContext.extensionUsageTracker);
+ sourceEmitter.getGLSLExtensionTracker());
#if 0
dumpIRIfEnabled(compileRequest, irModule, "GLSL LEGALIZED");
@@ -476,14 +474,14 @@ String emitEntryPoint(
case Stage::RayGeneration:
if( target == CodeGenTarget::GLSL )
{
- emitContext.extensionUsageTracker.requireGLSLExtension("GL_NV_ray_tracing");
- emitContext.extensionUsageTracker.requireGLSLVersion(ProfileVersion::GLSL_460);
+ sourceEmitter.getGLSLExtensionTracker()->requireExtension("GL_NV_ray_tracing");
+ sourceEmitter.getGLSLExtensionTracker()->requireVersion(ProfileVersion::GLSL_460);
}
break;
}
- String code = sourceStream.getContent();
- sourceStream.clearContent();
+ String code = sourceWriter.getContent();
+ sourceWriter.clearContent();
// Now that we've emitted the code for all the declarations in the file,
// it is time to stitch together the final output.
@@ -493,12 +491,12 @@ String emitEntryPoint(
sourceEmitter.emitLayoutDirectives(targetRequest);
- String prefix = sourceStream.getContent();
+ String prefix = sourceWriter.getContent();
StringBuilder finalResultBuilder;
finalResultBuilder << prefix;
- finalResultBuilder << emitContext.extensionUsageTracker.getGLSLExtensionRequireLines();
+ finalResultBuilder << sourceEmitter.getGLSLExtensionTracker()->getExtensionRequireLines();
finalResultBuilder << code;
diff --git a/source/slang/slang-extension-usage-tracker.cpp b/source/slang/slang-extension-usage-tracker.cpp
deleted file mode 100644
index f679e15db..000000000
--- a/source/slang/slang-extension-usage-tracker.cpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// slang-extension-usage-tracker.cpp
-#include "slang-extension-usage-tracker.h"
-
-namespace Slang {
-
-void ExtensionUsageTracker::requireGLSLExtension(const String& name)
-{
- if (m_glslExtensionsRequired.Contains(name))
- return;
-
- StringBuilder& sb = m_glslExtensionRequireLines;
-
- sb.append("#extension ");
- sb.append(name);
- sb.append(" : require\n");
-
- m_glslExtensionsRequired.Add(name);
-}
-
-void ExtensionUsageTracker::requireGLSLVersion(ProfileVersion version)
-{
- // Check if this profile is newer
- if ((UInt)version > (UInt)m_glslProfileVersion)
- {
- m_glslProfileVersion = version;
- }
-}
-
-void ExtensionUsageTracker::requireGLSLHalfExtension()
-{
- if (!m_hasGLSLHalfExtension)
- {
- // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_16bit_storage.txt
- requireGLSLExtension("GL_EXT_shader_16bit_storage");
-
- // https://github.com/KhronosGroup/GLSL/blob/master/extensions/ext/GL_EXT_shader_explicit_arithmetic_types.txt
- requireGLSLExtension("GL_EXT_shader_explicit_arithmetic_types");
-
- m_hasGLSLHalfExtension = true;
- }
-}
-
-
-} // namespace Slang
diff --git a/source/slang/slang-extension-usage-tracker.h b/source/slang/slang-extension-usage-tracker.h
deleted file mode 100644
index d17a7a6a1..000000000
--- a/source/slang/slang-extension-usage-tracker.h
+++ /dev/null
@@ -1,34 +0,0 @@
-// slang-extension-usage-tracker.h
-#ifndef SLANG_EXTENSION_USAGE_TRACKER_H_INCLUDED
-#define SLANG_EXTENSION_USAGE_TRACKER_H_INCLUDED
-
-#include "../core/slang-basic.h"
-
-#include "slang-compiler.h"
-
-namespace Slang
-{
-
-class ExtensionUsageTracker
-{
-public:
-
- void requireGLSLExtension(const String& name);
- void requireGLSLVersion(ProfileVersion version);
- void requireGLSLHalfExtension();
-
- ProfileVersion getRequiredGLSLProfileVersion() const { return m_glslProfileVersion; }
- const StringBuilder& getGLSLExtensionRequireLines() const { return m_glslExtensionRequireLines; }
-
-protected:
- // Record the GLSL extensions we have already emitted a `#extension` for
- HashSet<String> m_glslExtensionsRequired;
- StringBuilder m_glslExtensionRequireLines;
-
- ProfileVersion m_glslProfileVersion = ProfileVersion::GLSL_110;
-
- bool m_hasGLSLHalfExtension = false;
-};
-
-}
-#endif
diff --git a/source/slang/slang-ir-glsl-legalize.cpp b/source/slang/slang-ir-glsl-legalize.cpp
index 1e42cba62..c78b84cac 100644
--- a/source/slang/slang-ir-glsl-legalize.cpp
+++ b/source/slang/slang-ir-glsl-legalize.cpp
@@ -4,7 +4,7 @@
#include "slang-ir.h"
#include "slang-ir-insts.h"
-#include "slang-extension-usage-tracker.h"
+#include "slang-emit-glsl-extension-tracker.h"
namespace Slang
{
@@ -179,18 +179,18 @@ struct GLSLSystemValueInfo
struct GLSLLegalizationContext
{
Session* session;
- ExtensionUsageTracker* extensionUsageTracker;
+ GLSLExtensionTracker* glslExtensionTracker;
DiagnosticSink* sink;
Stage stage;
void requireGLSLExtension(String const& name)
{
- extensionUsageTracker->requireGLSLExtension(name);
+ glslExtensionTracker->requireExtension(name);
}
void requireGLSLVersion(ProfileVersion version)
{
- extensionUsageTracker->requireGLSLVersion(version);
+ glslExtensionTracker->requireVersion(version);
}
Stage getStage()
@@ -1511,7 +1511,7 @@ void legalizeEntryPointForGLSL(
IRModule* module,
IRFunc* func,
DiagnosticSink* sink,
- ExtensionUsageTracker* extensionUsageTracker)
+ GLSLExtensionTracker* glslExtensionTracker)
{
auto layoutDecoration = func->findDecoration<IRLayoutDecoration>();
SLANG_ASSERT(layoutDecoration);
@@ -1523,7 +1523,7 @@ void legalizeEntryPointForGLSL(
context.session = session;
context.stage = entryPointLayout->profile.GetStage();
context.sink = sink;
- context.extensionUsageTracker = extensionUsageTracker;
+ context.glslExtensionTracker = glslExtensionTracker;
Stage stage = entryPointLayout->profile.GetStage();
diff --git a/source/slang/slang-ir-glsl-legalize.h b/source/slang/slang-ir-glsl-legalize.h
index 3694005b3..e525f2791 100644
--- a/source/slang/slang-ir-glsl-legalize.h
+++ b/source/slang/slang-ir-glsl-legalize.h
@@ -7,7 +7,7 @@ namespace Slang
class DiagnosticSink;
class Session;
-class ExtensionUsageTracker;
+class GLSLExtensionTracker;
struct IRFunc;
struct IRModule;
@@ -17,6 +17,6 @@ void legalizeEntryPointForGLSL(
IRModule* module,
IRFunc* func,
DiagnosticSink* sink,
- ExtensionUsageTracker* extensionUsageTracker);
+ GLSLExtensionTracker* glslExtensionTracker);
}
diff --git a/source/slang/slang.vcxproj b/source/slang/slang.vcxproj
index 3f10a36e1..3b302fbcb 100644
--- a/source/slang/slang.vcxproj
+++ b/source/slang/slang.vcxproj
@@ -174,17 +174,17 @@
<ClInclude Include="core.meta.slang.h" />
<ClInclude Include="glsl.meta.slang.h" />
<ClInclude Include="hlsl.meta.slang.h" />
- <ClInclude Include="slang-c-like-source-emitter.h" />
<ClInclude Include="slang-check.h" />
<ClInclude Include="slang-compiler.h" />
<ClInclude Include="slang-decl-defs.h" />
<ClInclude Include="slang-diagnostic-defs.h" />
<ClInclude Include="slang-diagnostics.h" />
- <ClInclude Include="slang-emit-context.h" />
+ <ClInclude Include="slang-emit-c-like.h" />
+ <ClInclude Include="slang-emit-glsl-extension-tracker.h" />
<ClInclude Include="slang-emit-precedence.h" />
+ <ClInclude Include="slang-emit-source-writer.h" />
<ClInclude Include="slang-emit.h" />
<ClInclude Include="slang-expr-defs.h" />
- <ClInclude Include="slang-extension-usage-tracker.h" />
<ClInclude Include="slang-file-system.h" />
<ClInclude Include="slang-image-format-defs.h" />
<ClInclude Include="slang-ir-bind-existentials.h" />
@@ -225,7 +225,6 @@
<ClInclude Include="slang-profile.h" />
<ClInclude Include="slang-reflection.h" />
<ClInclude Include="slang-source-loc.h" />
- <ClInclude Include="slang-source-stream.h" />
<ClInclude Include="slang-stmt-defs.h" />
<ClInclude Include="slang-syntax-base-defs.h" />
<ClInclude Include="slang-syntax-defs.h" />
@@ -240,15 +239,15 @@
<ClInclude Include="slang-visitor.h" />
</ItemGroup>
<ItemGroup>
- <ClCompile Include="slang-c-like-source-emitter.cpp" />
<ClCompile Include="slang-check.cpp" />
<ClCompile Include="slang-compiler.cpp" />
<ClCompile Include="slang-diagnostics.cpp" />
<ClCompile Include="slang-dxc-support.cpp" />
- <ClCompile Include="slang-emit-context.cpp" />
+ <ClCompile Include="slang-emit-c-like.cpp" />
+ <ClCompile Include="slang-emit-glsl-extension-tracker.cpp" />
<ClCompile Include="slang-emit-precedence.cpp" />
+ <ClCompile Include="slang-emit-source-writer.cpp" />
<ClCompile Include="slang-emit.cpp" />
- <ClCompile Include="slang-extension-usage-tracker.cpp" />
<ClCompile Include="slang-file-system.cpp" />
<ClCompile Include="slang-ir-bind-existentials.cpp" />
<ClCompile Include="slang-ir-clone.cpp" />
@@ -284,7 +283,6 @@
<ClCompile Include="slang-profile.cpp" />
<ClCompile Include="slang-reflection.cpp" />
<ClCompile Include="slang-source-loc.cpp" />
- <ClCompile Include="slang-source-stream.cpp" />
<ClCompile Include="slang-stdlib.cpp" />
<ClCompile Include="slang-syntax.cpp" />
<ClCompile Include="slang-token.cpp" />
diff --git a/source/slang/slang.vcxproj.filters b/source/slang/slang.vcxproj.filters
index 7103749c0..1edcba640 100644
--- a/source/slang/slang.vcxproj.filters
+++ b/source/slang/slang.vcxproj.filters
@@ -21,9 +21,6 @@
<ClInclude Include="hlsl.meta.slang.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-c-like-source-emitter.h">
- <Filter>Header Files</Filter>
- </ClInclude>
<ClInclude Include="slang-check.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -39,19 +36,22 @@
<ClInclude Include="slang-diagnostics.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-emit-context.h">
+ <ClInclude Include="slang-emit-c-like.h">
+ <Filter>Header Files</Filter>
+ </ClInclude>
+ <ClInclude Include="slang-emit-glsl-extension-tracker.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="slang-emit-precedence.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-emit.h">
+ <ClInclude Include="slang-emit-source-writer.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-expr-defs.h">
+ <ClInclude Include="slang-emit.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-extension-usage-tracker.h">
+ <ClInclude Include="slang-expr-defs.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="slang-file-system.h">
@@ -174,9 +174,6 @@
<ClInclude Include="slang-source-loc.h">
<Filter>Header Files</Filter>
</ClInclude>
- <ClInclude Include="slang-source-stream.h">
- <Filter>Header Files</Filter>
- </ClInclude>
<ClInclude Include="slang-stmt-defs.h">
<Filter>Header Files</Filter>
</ClInclude>
@@ -215,9 +212,6 @@
</ClInclude>
</ItemGroup>
<ItemGroup>
- <ClCompile Include="slang-c-like-source-emitter.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
<ClCompile Include="slang-check.cpp">
<Filter>Source Files</Filter>
</ClCompile>
@@ -230,16 +224,19 @@
<ClCompile Include="slang-dxc-support.cpp">
<Filter>Source Files</Filter>
</ClCompile>
- <ClCompile Include="slang-emit-context.cpp">
+ <ClCompile Include="slang-emit-c-like.cpp">
+ <Filter>Source Files</Filter>
+ </ClCompile>
+ <ClCompile Include="slang-emit-glsl-extension-tracker.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="slang-emit-precedence.cpp">
<Filter>Source Files</Filter>
</ClCompile>
- <ClCompile Include="slang-emit.cpp">
+ <ClCompile Include="slang-emit-source-writer.cpp">
<Filter>Source Files</Filter>
</ClCompile>
- <ClCompile Include="slang-extension-usage-tracker.cpp">
+ <ClCompile Include="slang-emit.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="slang-file-system.cpp">
@@ -347,9 +344,6 @@
<ClCompile Include="slang-source-loc.cpp">
<Filter>Source Files</Filter>
</ClCompile>
- <ClCompile Include="slang-source-stream.cpp">
- <Filter>Source Files</Filter>
- </ClCompile>
<ClCompile Include="slang-stdlib.cpp">
<Filter>Source Files</Filter>
</ClCompile>
generated by cgit v1.2.3 (git 2.39.1) at 2026-06-01 21:37:37 +0000