Emit pointers for CPU target. (#1418)

Co-authored-by: Yong He <yhe@nvidia.com>

5 files changed, 188 insertions, 96 deletions

diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang
index d8e6cfce3..8a7c3a010 100644
--- a/source/slang/hlsl.meta.slang
+++ b/source/slang/hlsl.meta.slang
@@ -1427,123 +1427,123 @@ void GroupMemoryBarrierWithGroupSync();
 // Atomics
 
 __target_intrinsic(glsl, "$atomicAdd($A, $1)")
-__target_intrinsic(cuda, "atomicAdd(&$0, $1)")
+__target_intrinsic(cuda, "atomicAdd($0, $1)")
 void InterlockedAdd(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicAdd($A, $1)")
-__target_intrinsic(cuda, "atomicAdd((uint*)&$0, $1)")
+__target_intrinsic(cuda, "atomicAdd((uint*)$0, $1)")
 void InterlockedAdd(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicAdd(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicAdd($0, $1))")
 void InterlockedAdd(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicAdd($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicAdd((uint*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicAdd((uint*)$0, $1))")
 void InterlockedAdd(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicAnd($A, $1)")
-__target_intrinsic(cuda, "atomicAnd(&$0, $1)")
+__target_intrinsic(cuda, "atomicAnd($0, $1)")
 void InterlockedAnd(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicAnd($A, $1)")
-__target_intrinsic(cuda, "atomicAnd((int*)&$0, $1)")
+__target_intrinsic(cuda, "atomicAnd((int*)$0, $1)")
 void InterlockedAnd(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicAnd(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicAnd($0, $1))")
 void InterlockedAnd(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicAnd($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicAnd((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicAnd((int*)$0, $1))")
 void InterlockedAnd(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")
-__target_intrinsic(cuda, "($3 = atomicCAS(&$0, $1, $2))")
+__target_intrinsic(cuda, "(*$3 = atomicCAS($0, $1, $2))")
 void InterlockedCompareExchange(__ref  int dest,  int compare_value,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($3 = $atomicCompSwap($A, $1, $2))")
-__target_intrinsic(cuda, "($3 = (uint)atomicCAS((int*)&$0, $1, $2))")
+__target_intrinsic(cuda, "(*$3 = (uint)atomicCAS((int*)$0, $1, $2))")
 void InterlockedCompareExchange(__ref uint dest, uint compare_value, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")
-__target_intrinsic(cuda, "atomicCAS(&$0, $1, $2)")
+__target_intrinsic(cuda, "atomicCAS($0, $1, $2)")
 void InterlockedCompareStore(__ref int dest,  int compare_value,  int value);
 
 __target_intrinsic(glsl, "$atomicCompSwap($A, $1, $2)")
-__target_intrinsic(cuda, "atomicCAS((int*)&$0, $1, $2)")
+__target_intrinsic(cuda, "atomicCAS((int*)$0, $1, $2)")
 void InterlockedCompareStore(__ref uint dest, uint compare_value, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicExch(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicExch($0, $1))")
 void InterlockedExchange(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicExchange($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicExch((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicExch((int*)$0, $1))")
 void InterlockedExchange(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicMax($A, $1)")
-__target_intrinsic(cuda, "atomicMax(&$0, $1)")
+__target_intrinsic(cuda, "atomicMax($0, $1)")
 void InterlockedMax(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicMax($A, $1)")
-__target_intrinsic(cuda, "atomicMax((int*)&$0, $1)")
+__target_intrinsic(cuda, "atomicMax((int*)$0, $1)")
 void InterlockedMax(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicMax(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicMax($0, $1))")
 void InterlockedMax(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicMax($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicMax((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicMax((int*)$0, $1))")
 void InterlockedMax(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicMin($A, $1)")
-__target_intrinsic(cuda, "atomicMin(&$0, $1)")
+__target_intrinsic(cuda, "atomicMin($0, $1)")
 void InterlockedMin(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicMin($A, $1)")
-__target_intrinsic(cuda, "atomicMin((int*)&$0, $1)")
+__target_intrinsic(cuda, "atomicMin((int*)$0, $1)")
 void InterlockedMin(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicMin(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicMin($0, $1))")
 void InterlockedMin(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicMin($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicMin((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicMin((int*)$0, $1))")
 void InterlockedMin(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicOr($A, $1)")
-__target_intrinsic(cuda, "atomicOr(&$0, $1)")
+__target_intrinsic(cuda, "atomicOr($0, $1)")
 void InterlockedOr(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicOr($A, $1)")
-__target_intrinsic(cuda, "atomicOr((int*)&$0, $1)")
+__target_intrinsic(cuda, "atomicOr((int*)$0, $1)")
 void InterlockedOr(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicOr(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicOr($0, $1))")
 void InterlockedOr(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicOr($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicOr((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicOr((int*)$0, $1))")
 void InterlockedOr(__ref uint dest, uint value, out uint original_value);
 
 __target_intrinsic(glsl, "$atomicXor($A, $1)")
-__target_intrinsic(cuda, "atomicXor(&$0, $1)")
+__target_intrinsic(cuda, "atomicXor($0, $1)")
 void InterlockedXor(__ref  int dest,  int value);
 
 __target_intrinsic(glsl, "$atomicXor($A, $1)")
-__target_intrinsic(cuda, "atomicXor((int*)&$0, $1)")
+__target_intrinsic(cuda, "atomicXor((int*)$0, $1)")
 void InterlockedXor(__ref uint dest, uint value);
 
 __target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")
-__target_intrinsic(cuda, "($2 = atomicXor(&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = atomicXor($0, $1))")
 void InterlockedXor(__ref  int dest,  int value, out  int original_value);
 
 __target_intrinsic(glsl, "($2 = $atomicXor($A, $1))")
-__target_intrinsic(cuda, "($2 = (uint)atomicXor((int*)&$0, $1))")
+__target_intrinsic(cuda, "(*$2 = (uint)atomicXor((int*)$0, $1))")
 void InterlockedXor(__ref uint dest, uint value, out uint original_value);
 
 // Is floating-point value finite?
diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp
index b1a664ade..2f0b0b035 100644
--- a/source/slang/slang-emit-c-like.cpp
+++ b/source/slang/slang-emit-c-like.cpp
@@ -969,10 +969,11 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst)
         type = arrayType->getElementType();
     }
 
-    // Don't allow temporaries of pointer types to be created.
+    // Don't allow temporaries of pointer types to be created,
+    // if target langauge doesn't support pointers.
     if(as<IRPtrTypeBase>(type))
     {
-        return true;
+        return !doesTargetSupportPtrTypes();
     }
 
     // First we check for uniform parameter groups,
@@ -1161,6 +1162,50 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst)
     return true;
 }
 
+void CLikeSourceEmitter::emitDereferenceOperand(IRInst* inst, EmitOpInfo const& outerPrec)
+{
+    if (doesTargetSupportPtrTypes())
+    {
+        // If `inst` is a variable, dereferencing it is equivalent to just
+        // emit its name. i.e. *&var ==> var.
+        // We apply this peep hole optimization here to reduce the clutter of
+        // resulting code.
+        if (inst->op == kIROp_Var)
+        {
+            m_writer->emit(getName(inst));
+            return;
+        }
+
+        auto dereferencePrec = EmitOpInfo::get(EmitOp::Prefix);
+        EmitOpInfo newOuterPrec = outerPrec;
+        bool needClose = maybeEmitParens(newOuterPrec, dereferencePrec);
+        m_writer->emit("*");
+        emitOperand(inst, rightSide(newOuterPrec, dereferencePrec));
+        maybeCloseParens(needClose);
+    }
+    else
+    {
+        emitOperand(inst, outerPrec);
+    }
+}
+
+void CLikeSourceEmitter::emitVarExpr(IRInst* inst, EmitOpInfo const& outerPrec)
+{
+    if (doesTargetSupportPtrTypes())
+    {
+        auto prec = getInfo(EmitOp::Prefix);
+        auto newOuterPrec = outerPrec;
+        bool needClose = maybeEmitParens(newOuterPrec, prec);
+        m_writer->emit("&");
+        m_writer->emit(getName(inst));
+        maybeCloseParens(needClose);
+    }
+    else
+    {
+        m_writer->emit(getName(inst));
+    }
+}
+
 void CLikeSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const&  outerPrec)
 {
     if( shouldFoldInstIntoUseSites(inst) )
@@ -1171,7 +1216,10 @@ void CLikeSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const&  outerP
 
     switch(inst->op)
     {
-    case 0: // nothing yet
+    case kIROp_Var:
+    case kIROp_GlobalVar:
+        emitVarExpr(inst, outerPrec);
+        break;
     default:
         m_writer->emit(getName(inst));
         break;
@@ -2019,18 +2067,35 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
 
         IRFieldAddress* ii = (IRFieldAddress*) inst;
 
-        auto prec = getInfo(EmitOp::Postfix);
-        needClose = maybeEmitParens(outerPrec, prec);
-
-        auto base = ii->getBase();
-        emitOperand(base, leftSide(outerPrec, prec));
-        m_writer->emit(".");
-        if(getSourceLanguage() == SourceLanguage::GLSL
-            && as<IRUniformParameterGroupType>(base->getDataType()))
+        if (doesTargetSupportPtrTypes())
         {
-            m_writer->emit("_data.");
+            auto prec = getInfo(EmitOp::Prefix);
+            needClose = maybeEmitParens(outerPrec, prec);
+            m_writer->emit("&");
+            outerPrec = rightSide(outerPrec, prec);
+            auto innerPrec = getInfo(EmitOp::Postfix);
+            bool innerNeedClose = maybeEmitParens(outerPrec, innerPrec);
+            auto base = ii->getBase();
+            emitOperand(base, leftSide(outerPrec, innerPrec));
+            m_writer->emit("->");
+            m_writer->emit(getName(ii->getField()));
+            maybeCloseParens(innerNeedClose);
+        }
+        else
+        {
+            auto prec = getInfo(EmitOp::Postfix);
+            needClose = maybeEmitParens(outerPrec, prec);
+
+            auto base = ii->getBase();
+            emitOperand(base, leftSide(outerPrec, prec));
+            m_writer->emit(".");
+            if(getSourceLanguage() == SourceLanguage::GLSL
+                && as<IRUniformParameterGroupType>(base->getDataType()))
+            {
+                m_writer->emit("_data.");
+            }
+            m_writer->emit(getName(ii->getField()));
         }
-        m_writer->emit(getName(ii->getField()));
         break;
     }
 
@@ -2121,7 +2186,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
     case kIROp_Load:
         {
             auto base = inst->getOperand(0);
-            emitOperand(base, outerPrec);
+            emitDereferenceOperand(base, outerPrec);
             if(getSourceLanguage() == SourceLanguage::GLSL
                 && as<IRUniformParameterGroupType>(base->getDataType()))
             {
@@ -2135,7 +2200,7 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
             auto prec = getInfo(EmitOp::Assign);
             needClose = maybeEmitParens(outerPrec, prec);
 
-            emitOperand(inst->getOperand(0), leftSide(outerPrec, prec));
+            emitDereferenceOperand(inst->getOperand(0), leftSide(outerPrec, prec));
             m_writer->emit(" = ");
             emitOperand(inst->getOperand(1), rightSide(prec, outerPrec));
         }
@@ -2169,13 +2234,31 @@ void CLikeSourceEmitter::defaultEmitInstExpr(IRInst* inst, const EmitOpInfo& inO
         }
         else
         {
-            auto prec = getInfo(EmitOp::Postfix);
-            needClose = maybeEmitParens(outerPrec, prec);
+            if (inst->op == kIROp_getElementPtr && doesTargetSupportPtrTypes())
+            {
+                const auto info = getInfo(EmitOp::Prefix);
+                needClose = maybeEmitParens(outerPrec, info);
+                m_writer->emit("&");
+                auto rightSidePrec = rightSide(outerPrec, info);
+                auto postfixInfo = getInfo(EmitOp::Postfix);
+                bool rightSideNeedClose = maybeEmitParens(rightSidePrec, postfixInfo);
+                emitDereferenceOperand(inst->getOperand(0), leftSide(rightSidePrec, postfixInfo));
+                m_writer->emit("[");
+                emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
+                m_writer->emit("]");
+                maybeCloseParens(rightSideNeedClose);
+                break;
+            }
+            else
+            {
+                auto prec = getInfo(EmitOp::Postfix);
+                needClose = maybeEmitParens(outerPrec, prec);
 
-            emitOperand( inst->getOperand(0), leftSide(outerPrec, prec));
-            m_writer->emit("[");
-            emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
-            m_writer->emit("]");
+                emitOperand(inst->getOperand(0), leftSide(outerPrec, prec));
+                m_writer->emit("[");
+                emitOperand(inst->getOperand(1), getInfo(EmitOp::General));
+                m_writer->emit("]");
+            }
         }
         break;
 
@@ -2436,7 +2519,7 @@ void CLikeSourceEmitter::_emitInst(IRInst* inst)
 
 
             auto ii = cast<IRSwizzledStore>(inst);
-            emitOperand(ii->getDest(), leftSide(subscriptOuter, subscriptPrec));
+            emitDereferenceOperand(ii->getDest(), leftSide(subscriptOuter, subscriptPrec));
             m_writer->emit(".");
             UInt elementCount = ii->getElementCount();
             for (UInt ee = 0; ee < elementCount; ++ee)
diff --git a/source/slang/slang-emit-c-like.h b/source/slang/slang-emit-c-like.h
index 453a8dbbf..c37a1514e 100644
--- a/source/slang/slang-emit-c-like.h
+++ b/source/slang/slang-emit-c-like.h
@@ -262,6 +262,7 @@ public:
     void emitParameterGroup(IRGlobalParam* varDecl, IRUniformParameterGroupType* type);
 
     void emitVar(IRVar* varDecl);
+    void emitDereferenceOperand(IRInst* inst, EmitOpInfo const& outerPrec);
 
     void emitGlobalVar(IRGlobalVar* varDecl);
     void emitGlobalParam(IRGlobalParam* varDecl);
@@ -298,6 +299,7 @@ public:
 
     protected:
 
+    virtual bool doesTargetSupportPtrTypes() { return false; }
     virtual void emitLayoutSemanticsImpl(IRInst* inst, char const* uniformSemanticSpelling = "register") { SLANG_UNUSED(inst); SLANG_UNUSED(uniformSemanticSpelling); }
     virtual void emitParameterGroupImpl(IRGlobalParam* varDecl, IRUniformParameterGroupType* type) = 0;
     virtual void emitEntryPointAttributesImpl(IRFunc* irFunc, IREntryPointDecoration* entryPointDecor) = 0;
@@ -318,6 +320,7 @@ public:
     virtual void emitSimpleValueImpl(IRInst* inst);
     virtual void emitModuleImpl(IRModule* module);
     virtual void emitSimpleFuncImpl(IRFunc* func);
+    virtual void emitVarExpr(IRInst* inst, EmitOpInfo const& outerPrec);
     virtual void emitOperandImpl(IRInst* inst, EmitOpInfo const& outerPrec);
     virtual void emitParamTypeImpl(IRType* type, String const& name);
     virtual void emitIntrinsicCallExprImpl(IRCall* inst, IRTargetIntrinsicDecoration* targetIntrinsic, EmitOpInfo const& inOuterPrec);
diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp
index 7f743d9e0..6b7fc46bf 100644
--- a/source/slang/slang-emit-cpp.cpp
+++ b/source/slang/slang-emit-cpp.cpp
@@ -398,10 +398,7 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
         {
             auto ptrType = static_cast<IRPtrType*>(type);
             SLANG_RETURN_ON_FAIL(calcTypeName(ptrType->getValueType(), target, out));
-            // TODO(JS): It seems although it says it is a pointer, it can actually be output as a reference
-            // not clear where the ptr aspect is there, as in the definition it is just 'out', implying out
-            // is somewhere converted to a ptr?
-            out << "&";
+            out << "*";
             return SLANG_OK;
         }
         case kIROp_RefType:
@@ -577,14 +574,6 @@ SlangResult CPPSourceEmitter::calcTypeName(IRType* type, CodeGenTarget target, S
 
 void CPPSourceEmitter::useType(IRType* type)
 {
-    if (type->op == kIROp_PtrType)
-    {
-        // TODO(JS):
-        // If it's a pointer type we ignore. We may want to strip but in practice it's
-        // probably not necessary.
-        return;
-    }
-
     _getTypeName(type);
 }
 
@@ -934,22 +923,26 @@ void CPPSourceEmitter::_emitGetAtDefinition(const UnownedStringSlice& funcName,
 
     IRType* srcType = funcType->getParamType(0);
 
-    for (Index i = 0; i < 2; ++i)
+    for (Index i = 0; i < 3; ++i)
     {
         UnownedStringSlice typePrefix = (i == 0) ? UnownedStringSlice::fromLiteral("const ") : UnownedStringSlice();
+        bool lValue = (i != 2);
 
         emitFunctionPreambleImpl(nullptr);
 
         writer->emit(typePrefix);
         emitType(specOp->returnType);
-        m_writer->emit("& ");
-
+        if (lValue)
+            m_writer->emit("*");
+        writer->emit(" ");
         writer->emit(funcName);
         writer->emit("(");
 
         writer->emit(typePrefix);
         emitType(funcType->getParamType(0));
-        writer->emit("& a,  ");
+        if (lValue)
+            writer->emit("*");
+        writer->emit(" a,  ");
         emitType(funcType->getParamType(1));
         writer->emit(" b)\n{\n");
 
@@ -962,8 +955,10 @@ void CPPSourceEmitter::_emitGetAtDefinition(const UnownedStringSlice& funcName,
             writer->emit("assert(b >= 0 && b < ");
             writer->emit(vecSize);
             writer->emit(");\n");
-
-            writer->emit("return (&a.x)[b];\n");
+            if (lValue)
+                writer->emit("return (&a->x) + b;\n");
+            else
+                writer->emit("return (&a.x)[b];\n");
         }
         else if (auto matrixType = as<IRMatrixType>(srcType))
         {
@@ -974,7 +969,10 @@ void CPPSourceEmitter::_emitGetAtDefinition(const UnownedStringSlice& funcName,
             writer->emit(rowCount);
             writer->emit(");\n");
 
-            writer->emit("return a.rows[b];\n");
+            if (lValue)
+                writer->emit("return &(a->rows[b]);\n");
+            else
+                writer->emit("return a.rows[b];\n");
         }
 
         writer->dedent();
@@ -1566,7 +1564,7 @@ void CPPSourceEmitter::_emitInOutParamType(IRType* type, String const& name, IRT
 
     UnownedStringSlice slice = _getTypeName(valueType);
     m_writer->emit(slice);
-    m_writer->emit("& ");
+    m_writer->emit("* ");
     m_writer->emitName(nameAndLoc);
 }
 
@@ -2095,21 +2093,39 @@ void CPPSourceEmitter::emitIntrinsicCallExprImpl(
         else
         {
             // The user is invoking a built-in subscript operator
-            auto prec = getInfo(EmitOp::Postfix);
-            needClose = maybeEmitParens(outerPrec, prec);
 
-            emitOperand(args[0].get(), leftSide(outerPrec, prec));
-            m_writer->emit("[");
-            emitOperand(args[1].get(), getInfo(EmitOp::General));
-            m_writer->emit("]");
+            // Determine if we are calling the `ref` accessor:
+            // `ref` accessor returns a pointer of element type.
+            auto ptrType = as<IRPtrType>(inst->getFullType());
+            auto resourceType = inst->getOperand(1)->getFullType();
+            auto elementType = resourceType ? resourceType->getOperand(0) : nullptr;
+            bool isRef = ptrType && ptrType->getValueType() == elementType;
 
+            auto emitSubscript = [this, &args](EmitOpInfo _outerPrec)
+            {
+                auto prec = getInfo(EmitOp::Postfix);
+                bool needCloseSubscript = maybeEmitParens(_outerPrec, prec);
+                emitOperand(args[0].get(), leftSide(_outerPrec, prec));
+                m_writer->emit("[");
+                emitOperand(args[1].get(), getInfo(EmitOp::General));
+                m_writer->emit("]");
+                maybeCloseParens(needCloseSubscript);
+            };
+
+            if (isRef)
+            {
+                auto prefixPrec = getInfo(EmitOp::Prefix);
+                needClose = maybeEmitParens(outerPrec, prefixPrec);
+                m_writer->emit("&");
+                outerPrec = rightSide(outerPrec, prefixPrec);
+            }
+            emitSubscript(outerPrec);
+            maybeCloseParens(needClose);
             if (argCount == 3)
             {
                 m_writer->emit(" = ");
                 emitOperand(args[2].get(), getInfo(EmitOp::General));
             }
-
-            maybeCloseParens(needClose);
         }
 
         return;
@@ -2358,19 +2374,6 @@ void CPPSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const&  outerPre
             {
                 // It's in UniformState
                 m_writer->emit("(");
-
-                switch (inst->getDataType()->op)
-                {
-                    case kIROp_ParameterBlockType:
-                    case kIROp_ConstantBufferType:
-                    case kIROp_StructType:
-                    {
-                        m_writer->emit("*");
-                        break;
-                    }
-                    default: break;
-                }
-
                 m_writer->emit("uniformState->");
                 m_writer->emit(name);
                 m_writer->emit(")");
@@ -2408,12 +2411,14 @@ void CPPSourceEmitter::emitOperandImpl(IRInst* inst, EmitOpInfo const&  outerPre
                     }
                 }
             }
-
-            ;   // Fall-thru
+            m_writer->emit(getName(inst));
+            break;
         }
+        case kIROp_Var:
         case kIROp_GlobalVar:
+            emitVarExpr(inst, outerPrec);
+            break;
         default:
-            // GlobalVar should be fine as should just be a member of Context
             m_writer->emit(getName(inst));
             break;
     }
diff --git a/source/slang/slang-emit-cpp.h b/source/slang/slang-emit-cpp.h
index 6f91444a3..c64b92b0f 100644
--- a/source/slang/slang-emit-cpp.h
+++ b/source/slang/slang-emit-cpp.h
@@ -63,6 +63,7 @@ public:
 protected:
 
     // Implement CLikeSourceEmitter interface
+    virtual bool doesTargetSupportPtrTypes() SLANG_OVERRIDE { return true; }
     virtual void emitParameterGroupImpl(IRGlobalParam* varDecl, IRUniformParameterGroupType* type) SLANG_OVERRIDE;
     virtual void emitEntryPointAttributesImpl(IRFunc* irFunc, IREntryPointDecoration* entryPointDecor) SLANG_OVERRIDE;
     virtual void emitSimpleTypeImpl(IRType* type) SLANG_OVERRIDE;