Replace old notion of "intrinsic" operations

The code previously had an enumerated type for "intrinsic" operations, and allowed functions to be marked `__intrinsic_op(...)` to indicate the operation they map to.
The nature of the IR meant that each of these intrinsic ops had to have a corresponding IR opcode, but the `enum` types weren't the same.
This change cleans things up a bit by deciding that the `__intrinsic_op(...)` modifier names an actual IR opcode, and so the `IntrinsicOp` enum is gone.

The biggest source of complexity here is that there are certain operations that need to be "intrinsic"-ish for the purposes of the current AST-based translation path, because we need them to round-trip from source to AST and back.
Right now this is being handled by defining a bunch of "pseudo-ops" which can be used in the `__intrinsic_op` modifier, but which are *not* meant to be represented in the IR.
Currently I don't actually handle this during IR generation.
In the long run, once we are using IR for everything that needs cross-compilation, we should be able to eliminate the pseudo-ops in favor of just having these be ordinary (inline) functions defined in the stdlib (e.g., the `+=` operator can just have a direct definition).

There was a second category of modifier that gets a little caught up in this, which is the `__intrinsic` modifier, which got used in two ways:

1. A function marked `__intrinsic(glsl, ...)` had what I call a "target intrinsic" modifier, which specified how to lower it for a specific target (e.g., GLSL).

2. A function just marked `__intrinsic` was supposed to be a marker for "this function shouldn't be emitted in the output, because the implementation is expected to be provided"

The latter category of function should really be an `__intrinsic_op`, so I translated all those uses. I added a tiny bit of sugar so that `__intrinsic_op` without an explicit opcode will look up an opcode based on the name of the function being called, so that an operation like `sin` can automatically be plumbed through to an equivalent IR op. (The first category is a stopgap for the AST-based cross-compilation, and will hopefully be replaced by something better  as we get the IR-based path working).

Getting the switch from `__intrinsic` to `__intrinsic_op` working required shuffling around some code in `emit.cpp` that handles looking up those modifiers and emitting builtin operations appropriately during cross-compilation.

Depending on where we go with things, a possible extension of this approach is to allow multiple operands to `__intrinsic_op` so that the first specifies the opcode, and then the rest are literal arguments to specify "sub-ops." This could help us handle stuff like texture-fetch operations without an explosion in the number of opcodes. I still need to think about whether this is a good idea or not.

13 files changed, 959 insertions, 809 deletions

diff --git a/source/slang/emit.cpp b/source/slang/emit.cpp
index 450d9eb86..a0cf8eb19 100644
--- a/source/slang/emit.cpp
+++ b/source/slang/emit.cpp
@@ -2117,36 +2117,13 @@ struct EmitVisitor
                     return;
                 }
 
-                // TODO: emit as approperiate for this target
-
-                // We might be calling an intrinsic subscript operation,
-                // and should desugar it accordingly
-                if(auto subscriptDeclRef = funcDeclRef.As<SubscriptDecl>())
-                {
-                    // We expect any subscript operation to be invoked as a member,
-                    // so the function expression had better be in the correct form.
-                    if(auto memberExpr = funcExpr.As<MemberExpr>())
-                    {
-
-                        Emit("(");
-                        EmitExpr(memberExpr->BaseExpression);
-                        Emit(")[");
-                        UInt argCount = callExpr->Arguments.Count();
-                        for (UInt aa = 0; aa < argCount; ++aa)
-                        {
-                            if (aa != 0) Emit(", ");
-                            EmitExpr(callExpr->Arguments[aa]);
-                        }
-                        Emit("]");
-                        return;
-                    }
-                }
+                // If we fall through here, we will treat the call like any other.
             }
             else if (auto intrinsicOpModifier = funcDecl->FindModifier<IntrinsicOpModifier>())
             {
                 switch (intrinsicOpModifier->op)
                 {
-#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitBinExpr(outerPrec, kEOp_##NAME, #OP, callExpr); return
+#define CASE(NAME, OP) case kIROp_##NAME: EmitBinExpr(outerPrec, kEOp_##NAME, #OP, callExpr); return
                     CASE(Mul, *);
                     CASE(Div, / );
                     CASE(Mod, %);
@@ -2167,7 +2144,7 @@ struct EmitVisitor
                     CASE(Or, || );
 #undef CASE
 
-#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitBinAssignExpr(outerPrec, kEOp_##NAME, #OP, callExpr); return
+#define CASE(NAME, OP) case kIRPseudoOp_##NAME: EmitBinAssignExpr(outerPrec, kEOp_##NAME, #OP, callExpr); return
                     CASE(Assign, =);
                     CASE(AddAssign, +=);
                     CASE(SubAssign, -=);
@@ -2181,26 +2158,26 @@ struct EmitVisitor
                     CASE(XorAssign, ^=);
 #undef CASE
 
-                case IntrinsicOp::Sequence: EmitBinExpr(outerPrec, kEOp_Comma, ",", callExpr); return;
+                case kIRPseudoOp_Sequence: EmitBinExpr(outerPrec, kEOp_Comma, ",", callExpr); return;
 
-#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryExpr(outerPrec, kEOp_Prefix, #OP, "", callExpr); return
-                    CASE(Pos, +);
-                    CASE(Neg, -);
-                    CASE(Not, !);
-                    CASE(BitNot, ~);
+#define CASE(NAME, OP) case NAME: EmitUnaryExpr(outerPrec, kEOp_Prefix, #OP, "", callExpr); return
+                    CASE(kIRPseudoOp_Pos, +);
+                    CASE(kIROp_Neg, -);
+                    CASE(kIROp_Not, !);
+                    CASE(kIRPseudoOp_BitNot, ~);
 #undef CASE
 
-#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryAssignExpr(outerPrec, kEOp_Prefix, #OP, "", callExpr); return
+#define CASE(NAME, OP) case kIRPseudoOp_##NAME: EmitUnaryAssignExpr(outerPrec, kEOp_Prefix, #OP, "", callExpr); return
                     CASE(PreInc, ++);
                     CASE(PreDec, --);
 #undef CASE
 
-#define CASE(NAME, OP) case IntrinsicOp::NAME: EmitUnaryAssignExpr(outerPrec, kEOp_Postfix, "", #OP, callExpr); return
+#define CASE(NAME, OP) case kIRPseudoOp_##NAME: EmitUnaryAssignExpr(outerPrec, kEOp_Postfix, "", #OP, callExpr); return
                     CASE(PostInc, ++);
                     CASE(PostDec, --);
 #undef CASE
 
-                case IntrinsicOp::InnerProduct_Vector_Vector:
+                case kIROp_Dot:
                     // HLSL allows `mul()` to be used as a synonym for `dot()`,
                     // so we need to translate to `dot` for GLSL
                     if (context->shared->target == CodeGenTarget::GLSL)
@@ -2214,9 +2191,9 @@ struct EmitVisitor
                     }
                     break;
 
-                case IntrinsicOp::InnerProduct_Matrix_Matrix:
-                case IntrinsicOp::InnerProduct_Matrix_Vector:
-                case IntrinsicOp::InnerProduct_Vector_Matrix:
+                case kIROp_Mul_Matrix_Matrix:
+                case kIROp_Mul_Vector_Matrix:
+                case kIROp_Mul_Matrix_Vector:
                     // HLSL exposes these with the `mul()` function, while GLSL uses ordinary
                     // `operator*`.
                     //
@@ -2236,6 +2213,35 @@ struct EmitVisitor
                 default:
                     break;
                 }
+
+                // If none of the above matched, then we don't have a specific
+                // case implemented to handle the opcode on the callee.
+                //
+                // We do one more special-case check here, in case the operation
+                // is a "subscript" (array indexing) operation, because we'd
+                // generally like to reproduce those as array indexing operations
+                // in the output if that is how they were written in the input.
+                if(auto subscriptDeclRef = funcDeclRef.As<SubscriptDecl>())
+                {
+                    // We expect any subscript operation to be invoked as a member,
+                    // so the function expression had better be in the correct form.
+                    if(auto memberExpr = funcExpr.As<MemberExpr>())
+                    {
+
+                        Emit("(");
+                        EmitExpr(memberExpr->BaseExpression);
+                        Emit(")[");
+                        UInt argCount = callExpr->Arguments.Count();
+                        for (UInt aa = 0; aa < argCount; ++aa)
+                        {
+                            if (aa != 0) Emit(", ");
+                            EmitExpr(callExpr->Arguments[aa]);
+                        }
+                        Emit("]");
+                        return;
+                    }
+                }
+
             }
         }
         else if (auto overloadedExpr = funcExpr.As<OverloadedExpr>())
@@ -3377,6 +3383,36 @@ struct EmitVisitor
         return varLayout;
     }
 
+    void emitHLSLParameterBlockFieldLayoutSemantics(
+        RefPtr<VarLayout>   layout,
+        RefPtr<VarLayout>   fieldLayout)
+    {
+        for( auto rr : fieldLayout->resourceInfos )
+        {
+            auto kind = rr.kind;
+
+            auto offsetResource = rr;
+
+            if(kind != LayoutResourceKind::Uniform)
+            {
+                // Add the base index from the cbuffer into the index of the field
+                //
+                // TODO(tfoley): consider maybe not doing this, since it actually
+                // complicates logic around constant buffers...
+
+                // If the member of the cbuffer uses a resource, it had better
+                // appear as part of the cubffer layout as well.
+                auto cbufferResource = layout->FindResourceInfo(kind);
+                SLANG_RELEASE_ASSERT(cbufferResource);
+
+                offsetResource.index += cbufferResource->index;
+                offsetResource.space += cbufferResource->space;
+            }
+
+            emitHLSLRegisterSemantic(offsetResource, "packoffset");
+        }
+    }
+
     void emitHLSLParameterBlockDecl(
         RefPtr<VarDeclBase>             varDecl,
         RefPtr<ParameterBlockType>      parameterBlockType,
@@ -3436,30 +3472,7 @@ struct EmitVisitor
                 SLANG_RELEASE_ASSERT(fieldLayout->varDecl.GetName() == field.GetName());
 
                 // Emit explicit layout annotations for every field
-                for( auto rr : fieldLayout->resourceInfos )
-                {
-                    auto kind = rr.kind;
-
-                    auto offsetResource = rr;
-
-                    if(kind != LayoutResourceKind::Uniform)
-                    {
-                        // Add the base index from the cbuffer into the index of the field
-                        //
-                        // TODO(tfoley): consider maybe not doing this, since it actually
-                        // complicates logic around constant buffers...
-
-                        // If the member of the cbuffer uses a resource, it had better
-                        // appear as part of the cubffer layout as well.
-                        auto cbufferResource = layout->FindResourceInfo(kind);
-                        SLANG_RELEASE_ASSERT(cbufferResource);
-
-                        offsetResource.index += cbufferResource->index;
-                        offsetResource.space += cbufferResource->space;
-                    }
-
-                    emitHLSLRegisterSemantic(offsetResource, "packoffset");
-                }
+                emitHLSLParameterBlockFieldLayoutSemantics(layout, fieldLayout);
 
                 Emit(";\n");
             }
@@ -4261,14 +4274,14 @@ emitDeclImpl(decl, nullptr);
             }
             break;
 
-        case kIROp_Intrinsic_Add:
+        case kIROp_Add:
             emitIROperand(context, inst->getArg(1));
             emit(" + ");
             emitIROperand(context, inst->getArg(2));
             break;
 
 
-        case kIROp_Intrinsic_sample_t_s_u:
+        case kIROp_Sample:
             emitIROperand(context, inst->getArg(1));
             emit(".Sample(");
             emitIROperand(context, inst->getArg(2));
@@ -4277,6 +4290,19 @@ emitDeclImpl(decl, nullptr);
             emit(")");
             break;
 
+        case kIROp_SampleGrad:
+            emitIROperand(context, inst->getArg(1));
+            emit(".SampleGrad(");
+            emitIROperand(context, inst->getArg(2));
+            emit(", ");
+            emitIROperand(context, inst->getArg(3));
+            emit(", ");
+            emitIROperand(context, inst->getArg(4));
+            emit(", ");
+            emitIROperand(context, inst->getArg(5));
+            emit(")");
+            break;
+
         case kIROp_Load:
             // TODO: this logic will really only work for a simple variable reference...
             emitIROperand(context, inst->getArg(1));
@@ -4351,14 +4377,26 @@ emitDeclImpl(decl, nullptr);
         }
     }
 
+    VarLayout* getVarLayout(
+        EmitContext*    context,
+        IRInst*          var)
+    {
+        auto decoration = var->findDecoration<IRLayoutDecoration>();
+        if (!decoration)
+            return nullptr;
+
+        return (VarLayout*) decoration->layout;
+    }
+
     void emitIRLayoutSemantics(
         EmitContext*    context,
-        IRInst*         inst)
+        IRInst*         inst,
+        char const*     uniformSemanticSpelling = "register")
     {
-        auto decoration = inst->findDecoration<IRLayoutDecoration>();
-        if (decoration)
+        auto layout = getVarLayout(context, inst);
+        if (layout)
         {
-            emitHLSLRegisterSemantics((VarLayout*) decoration->layout);
+            emitHLSLRegisterSemantics(layout, uniformSemanticSpelling);
         }
     }
 
@@ -4439,21 +4477,54 @@ emitDeclImpl(decl, nullptr);
     {
         emit("cbuffer ");
         emit(getName(varDecl));
-        emitIRLayoutSemantics(context, varDecl);
+
+        auto layout = getVarLayout(context, varDecl);
+        assert(layout);
+
+        auto info = layout->FindResourceInfo(LayoutResourceKind::ConstantBuffer);
+        SLANG_RELEASE_ASSERT(info);
+        emitHLSLRegisterSemantic(*info);
+
         emit("\n{\n");
 
         auto elementType = type->getElementType();
+
+        auto typeLayout = layout->typeLayout;
+        if( auto parameterBlockTypeLayout = typeLayout.As<ParameterBlockTypeLayout>() )
+        {
+            typeLayout = parameterBlockTypeLayout->elementTypeLayout;
+        }
+
         switch( elementType->op )
         {
         case kIROp_StructType:
             {
                 auto structType = (IRStructDecl*) elementType;
+
+                auto structTypeLayout = typeLayout.As<StructTypeLayout>();
+                assert(structTypeLayout);
+
+                UInt fieldIndex = 0;
                 for(auto ff = structType->getFirstField(); ff; ff = ff->getNextField())
                 {
+                    // TODO: need a plan to deal with the case where the IR-level
+                    // `struct` type might not match the high-level type, so that
+                    // the numbering of fields is different.
+                    //
+                    // The right plan is probably to require that the lowering pass
+                    // create a fresh layout for any type/variable that it splits
+                    // in this fashion, so that the layout information it attaches
+                    // can always be assumed to apply to the actual instruciton.
+                    //
+
+                    auto fieldLayout = structTypeLayout->fields[fieldIndex++];
+
+
+
                     auto fieldType = ff->getFieldType();
                     emitIRType(context, fieldType, getName(ff));
 
-                    emitIRSemantics(context, ff);
+                    emitHLSLParameterBlockFieldLayoutSemantics(layout, fieldLayout);
 
                     emit(";\n");
                 }
diff --git a/source/slang/intrinsic-defs.h b/source/slang/intrinsic-defs.h
deleted file mode 100644
index 336f1eff1..000000000
--- a/source/slang/intrinsic-defs.h
+++ /dev/null
@@ -1,99 +0,0 @@
-// intrinsic-defs.h
-
-// The file is meant to be included multiple times, to produce different
-// pieces of code related to intrinsic operations
-//
-// Each intrinsic op is declared here with:
-//
-//      INTRINSIC(name)
-//
-
-#ifndef INTRINSIC
-#error Need to define INTRINSIC(NAME) before including "intrinsic-defs.h"
-#endif
-
-INTRINSIC(Add)
-INTRINSIC(Sub)
-INTRINSIC(Mul)
-INTRINSIC(Div)
-INTRINSIC(Mod)
-
-INTRINSIC(Lsh)
-INTRINSIC(Rsh)
-
-INTRINSIC(Eql)
-INTRINSIC(Neq)
-INTRINSIC(Greater)
-INTRINSIC(Less)
-INTRINSIC(Geq)
-INTRINSIC(Leq)
-INTRINSIC(BitAnd)
-INTRINSIC(BitXor)
-INTRINSIC(BitOr)
-
-// TODO(tfoley): need to distinguish short-circuiting and not...
-INTRINSIC(And)
-INTRINSIC(Or)
-
-INTRINSIC(Assign)
-INTRINSIC(AddAssign)
-INTRINSIC(SubAssign)
-INTRINSIC(MulAssign)
-INTRINSIC(DivAssign)
-INTRINSIC(ModAssign)
-INTRINSIC(LshAssign)
-INTRINSIC(RshAssign)
-INTRINSIC(OrAssign)
-INTRINSIC(AndAssign)
-INTRINSIC(XorAssign)
-INTRINSIC(Pos)
-INTRINSIC(Neg)
-INTRINSIC(Not)
-INTRINSIC(BitNot)
-INTRINSIC(PreInc)
-INTRINSIC(PreDec)
-INTRINSIC(PostInc)
-INTRINSIC(PostDec)
-
-INTRINSIC(Sequence)
-INTRINSIC(Select)
-
-INTRINSIC(Mul_Scalar_Scalar)
-INTRINSIC(Mul_Vector_Scalar)
-INTRINSIC(Mul_Scalar_Vector)
-INTRINSIC(Mul_Matrix_Scalar)
-INTRINSIC(Mul_Scalar_Matrix)
-INTRINSIC(InnerProduct_Vector_Vector)
-INTRINSIC(InnerProduct_Vector_Matrix)
-INTRINSIC(InnerProduct_Matrix_Vector)
-INTRINSIC(InnerProduct_Matrix_Matrix)
-
-// Texture sampling operation of the form `t.Sample(s,u)`
-INTRINSIC(sample_t_s_u)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-// Un-deefine the macor here, so that the client does not have to.
-#undef INTRINSIC
diff --git a/source/slang/ir-inst-defs.h b/source/slang/ir-inst-defs.h
index 2548dc22a..15a082aba 100644
--- a/source/slang/ir-inst-defs.h
+++ b/source/slang/ir-inst-defs.h
@@ -4,8 +4,15 @@
 #error Must #define `INST` before including `ir-inst-defs.h`
 #endif
 
+#ifndef PSEUDO_INST
+#define PSEUDO_INST(ID) /* empty */
+#endif
+
 #define PARENT kIROpFlag_Parent
 
+// Invalid operation: should not appear in valid code
+INST(Nop, nop, 0, 0)
+
 INST(TypeType,    type.type,      0, 0)
 INST(VoidType,    type.void,      0, 0)
 INST(BlockType,   type.block,     0, 0)
@@ -15,40 +22,139 @@ INST(Float32Type, type.f32,       0, 0)
 INST(Int32Type,   type.i32,       0, 0)
 INST(UInt32Type,  type.u32,       0, 0)
 INST(StructType,  type.struct,    0, PARENT)
-INST(FuncType,    func_type,      0, 0)
-INST(PtrType,       ptr_type,       1, 0)
-INST(TextureType,   texture_type,   2, 0)
-INST(SamplerType,   sampler_type,   1, 0)
-INST(ConstantBufferType,    constant_buffer_type,   1, 0)
-INST(TextureBufferType,     texture_buffer_type,   1, 0)
+INST(FuncType, func_type, 0, 0)
+INST(PtrType, ptr_type, 1, 0)
+INST(TextureType, texture_type, 2, 0)
+INST(SamplerType, sampler_type, 1, 0)
+INST(ConstantBufferType, constant_buffer_type, 1, 0)
+INST(TextureBufferType, texture_buffer_type, 1, 0)
 
-INST(IntLit,      integer_constant,   0, 0)
-INST(FloatLit,    float_constant,     0, 0)
+INST(IntLit, integer_constant, 0, 0)
+INST(FloatLit, float_constant, 0, 0)
 
-INST(Construct,   construct,        0, 0)
-INST(Call,          call,             1, 0)
+INST(Construct, construct, 0, 0)
+INST(Call, call, 1, 0)
 
-INST(Module,      module, 0, PARENT)
-INST(Func,        func,   0, PARENT)
-INST(Block,       block,  0, PARENT)
+INST(Module, module, 0, PARENT)
+INST(Func, func, 0, PARENT)
+INST(Block, block, 0, PARENT)
 
-INST(Param,         param,  0, 0)
-INST(StructField,   field,  0, 0)
-INST(Var,           var,    0, 0)
+INST(Param, param, 0, 0)
+INST(StructField, field, 0, 0)
+INST(Var, var, 0, 0)
 
-INST(Load,          load,   1, 0)
-INST(Store,         store,  2, 0)
+INST(Load, load, 1, 0)
+INST(Store, store, 2, 0)
 
-INST(FieldExtract,    get_field,        2, 0)
-INST(FieldAddress,    get_field_addr,   2, 0)
+INST(FieldExtract, get_field, 2, 0)
+INST(FieldAddress, get_field_addr, 2, 0)
 
-INST(ReturnVal,       return_val,     1, 0)
+INST(ReturnVal, return_val, 1, 0)
 INST(ReturnVoid, return_void, 1, 0)
 
-#define INTRINSIC(NAME)                     \
-    INST(Intrinsic_##NAME, intrinsic.NAME, 0, 0)
-#include "intrinsic-defs.h"
 
+INST(Add, add, 2, 0)
+INST(Sub, sub, 2, 0)
+INST(Mul, mul, 2, 0)
+INST(Div, div, 2, 0)
+INST(Mod, mod, 2, 0)
+
+INST(Lsh, shl, 2, 0)
+INST(Rsh, shr, 2, 0)
+
+INST(Eql, cmpEQ, 2, 0)
+INST(Neq, cmpNE, 2, 0)
+INST(Greater, cmpGT, 2, 0)
+INST(Less, cmpLT, 2, 0)
+INST(Geq, cmpGE, 2, 0)
+INST(Leq, cmpLE, 2, 0)
+
+INST(BitAnd, and, 2, 0)
+INST(BitXor, xor, 2, 0)
+INST(BitOr, or , 2, 0)
+
+INST(And, logicalAnd, 2, 0)
+INST(Or, logicalOr, 2, 0)
+
+#if 0
+INST(Assign, assign, 2, 0)
+INST(AddAssign, addAssign, 2, 0)
+INST(SubAssign, subAssign, 2, 0)
+INST(SubAssign, subAssign, 2, 0)
+
+INTRINSIC(SubAssign)
+INTRINSIC(MulAssign)
+INTRINSIC(DivAssign)
+INTRINSIC(ModAssign)
+INTRINSIC(LshAssign)
+INTRINSIC(RshAssign)
+INTRINSIC(OrAssign)
+INTRINSIC(AndAssign)
+INTRINSIC(XorAssign)
+INTRINSIC(Pos)
+#endif
+
+INST(Neg, neg, 1, 0)
+INST(Not, not, 1, 0)
+
+#if 0
+INTRINSIC(PreInc)
+INTRINSIC(PreDec)
+INTRINSIC(PostInc)
+INTRINSIC(PostDec)
+
+INTRINSIC(Sequence)
+#endif
+
+INST(Select, select, 3, 0)
+
+INST(Dot, dot, 2, 0)
+
+INST(Mul_Vector_Matrix, mulVectorMatrix, 2, 0)
+INST(Mul_Matrix_Vector, mulMatrixVector, 2, 0)
+INST(Mul_Matrix_Matrix, mulMatrixMatrix, 2, 0)
+
+#if 0
+INTRINSIC(Mul_Scalar_Scalar)
+INTRINSIC(Mul_Vector_Scalar)
+INTRINSIC(Mul_Scalar_Vector)
+INTRINSIC(Mul_Matrix_Scalar)
+INTRINSIC(Mul_Scalar_Matrix)
+INTRINSIC(InnerProduct_Vector_Vector)
+INTRINSIC(InnerProduct_Vector_Matrix)
+INTRINSIC(InnerProduct_Matrix_Vector)
+INTRINSIC(InnerProduct_Matrix_Matrix)
+#endif
+
+// Texture sampling operation of the form `t.Sample(s,u)`
+INST(Sample, sample, 3, 0)
+
+INST(SampleGrad, sampleGrad, 4, 0)
+
+PSEUDO_INST(Pos)
+PSEUDO_INST(PreInc)
+
+PSEUDO_INST(PreDec)
+PSEUDO_INST(PostInc)
+PSEUDO_INST(PostDec)
+PSEUDO_INST(Sequence)
+PSEUDO_INST(AddAssign)
+PSEUDO_INST(SubAssign)
+PSEUDO_INST(MulAssign)
+PSEUDO_INST(DivAssign)
+PSEUDO_INST(ModAssign)
+PSEUDO_INST(AndAssign)
+PSEUDO_INST(OrAssign)
+PSEUDO_INST(XorAssign )
+PSEUDO_INST(LshAssign)
+PSEUDO_INST(RshAssign)
+PSEUDO_INST(Assign)
+PSEUDO_INST(BitNot)
+PSEUDO_INST(And)
+PSEUDO_INST(Or)
+
+
+#undef PSEUDO_INST
 #undef PARENT
 #undef INST
 
diff --git a/source/slang/ir.cpp b/source/slang/ir.cpp
index 3f07a685f..e3647a47b 100644
--- a/source/slang/ir.cpp
+++ b/source/slang/ir.cpp
@@ -13,15 +13,24 @@ namespace Slang
 #include "ir-inst-defs.h"
     };
 
+    //
 
-    static const IROp kIRIntrinsicOps[] =
+    IROp findIROp(char const* name)
     {
-        (IROp) 0,
+        // TODO: need to make this faster by using a dictionary...
 
-#define INTRINSIC(NAME) kIROp_Intrinsic_##NAME,
-#include "intrinsic-defs.h"
+        if (0) {}
 
-    };
+#define INST(ID, MNEMONIC, ARG_COUNT, FLAGS)  \
+    else if(strcmp(name, #MNEMONIC) == 0) return kIROp_##ID;
+
+#define PSEUDO_INST(ID)  \
+    else if(strcmp(name, #ID) == 0) return kIRPseudoOp_##ID;
+
+#include "ir-inst-defs.h"
+
+        return IROp(kIROp_Invalid);
+    }
 
     //
 
@@ -767,13 +776,13 @@ namespace Slang
 
     IRInst* IRBuilder::emitIntrinsicInst(
         IRType*         type,
-        IntrinsicOp     intrinsicOp,
+        IROp            op,
         UInt            argCount,
         IRValue* const* args)
     {
         auto inst = createInstWithTrailingArgs<IRInst>(
             this,
-            kIRIntrinsicOps[(int)intrinsicOp],
+            op,
             type,
             argCount,
             args);
diff --git a/source/slang/ir.h b/source/slang/ir.h
index aa7b6a045..51755f89f 100644
--- a/source/slang/ir.h
+++ b/source/slang/ir.h
@@ -7,13 +7,36 @@
 // similar in spirit to LLVM (but much simpler).
 //
 
-#include "type-layout.h"
+#include "../core/basic.h"
 
-// We need the definition of `BaseType` which currently belongs to the AST
-#include "syntax.h"
 
 namespace Slang {
 
+// TODO(tfoley): We should ditch this enumeration
+// and just use the IR opcodes that represent these
+// types directly. The one major complication there
+// is that the order of the enum values currently
+// matters, since it determines promotion rank.
+// We either need to keep that restriction, or
+// look up promotion rank by some other means.
+//
+enum class BaseType
+{
+    // Note(tfoley): These are ordered in terms of promotion rank, so be vareful when messing with this
+
+    Void = 0,
+    Bool,
+    Int,
+    UInt,
+    UInt64,
+    Half,
+    Float,
+    Double,
+};
+
+
+class Layout;
+
 struct IRFunc;
 struct IRInst;
 struct IRModule;
@@ -29,14 +52,59 @@ enum : IROpFlags
     kIROpFlag_Parent = 1 << 0,
 };
 
-enum IROp : uint16_t
+enum IROp : int16_t
 {
-    
 #define INST(ID, MNEMONIC, ARG_COUNT, FLAGS)  \
     kIROp_##ID,
 
 #include "ir-inst-defs.h"
+
+    kIROpCount,
+
+    // We use the negative range of opcode values
+    // to encode "pseudo" instructions that should
+    // not appear in valid IR.
+
+    kIRPseduoOp_FirstPseudo = -1000,
+
+#define INST(ID, MNEMONIC, ARG_COUNT, FLAGS) /* empty */
+#define PSEUDO_INST(ID) kIRPseudoOp_##ID,
+
+#include "ir-inst-defs.h"
+
+    kIROp_Invalid = -1,
+
+};
+
+#if 0
+enum IRPseudoOp
+{
+    kIRPseudoOp_Pos         = -1000,
+    kIRPseudoOp_PreInc,
+    kIRPseudoOp_PreDec,
+    kIRPseudoOp_PostInc,
+    kIRPseudoOp_PostDec,
+    kIRPseudoOp_Sequence,
+    kIRPseudoOp_AddAssign,
+    kIRPseudoOp_SubAssign,
+    kIRPseudoOp_MulAssign,
+    kIRPseudoOp_DivAssign,
+    kIRPseudoOp_ModAssign,
+    kIRPseudoOp_AndAssign,
+    kIRPseudoOp_OrAssign,
+    kIRPseudoOp_XorAssign ,
+    kIRPseudoOp_LshAssign,
+    kIRPseudoOp_RshAssign,
+    kIRPseudoOp_Assign,
+    kIRPseudoOp_BitNot,
+    kIRPseudoOp_And,
+    kIRPseudoOp_Or,
+
+    kIROp_Invalid = -1,
 };
+#endif
+
+IROp findIROp(char const* name);
 
 // A logical operation/opcode in the IR
 struct IROpInfo
@@ -448,7 +516,7 @@ struct IRBuilder
 
     IRInst* emitIntrinsicInst(
         IRType*         type,
-        IntrinsicOp     intrinsicOp,
+        IROp            op,
         UInt            argCount,
         IRValue* const* args);
 
diff --git a/source/slang/lower-to-ir.cpp b/source/slang/lower-to-ir.cpp
index d4cac0337..a8acadb59 100644
--- a/source/slang/lower-to-ir.cpp
+++ b/source/slang/lower-to-ir.cpp
@@ -407,7 +407,7 @@ struct ExprLoweringVisitor : ExprVisitor<ExprLoweringVisitor, LoweredValInfo>
 
     LoweredValInfo lowerIntrinsicCall(
         InvokeExpr* expr,
-        IntrinsicOp intrinsicOp)
+        IROp intrinsicOp)
     {
         auto type = lowerSimpleType(context, expr->type);
 
@@ -431,6 +431,24 @@ struct ExprLoweringVisitor : ExprVisitor<ExprLoweringVisitor, LoweredValInfo>
         return LoweredValInfo::simple(getBuilder()->emitCallInst(type, getSimpleVal(loweredFunc), argCount, irArgs.Buffer()));
     }
 
+    IROp getIntrinsicOp(
+        Decl*                   decl,
+        IntrinsicOpModifier*    intrinsicOpMod)
+    {
+        if (int(intrinsicOpMod->op) != 0)
+            return intrinsicOpMod->op;
+
+        // No specified modifier? Then we need to look it up
+        // based on the name of the declaration...
+
+        auto name = decl->getName();
+        auto nameText = getText(name);
+
+        IROp op = findIROp(nameText.Buffer());
+        assert(op != kIROp_Invalid);
+        return op;
+    }
+
     LoweredValInfo visitInvokeExpr(InvokeExpr* expr)
     {
         // TODO: need to detect calls to builtins here, so that we can expand
@@ -443,7 +461,8 @@ struct ExprLoweringVisitor : ExprVisitor<ExprLoweringVisitor, LoweredValInfo>
             auto funcDecl = funcDeclRef.getDecl();
             if(auto intrinsicOpModifier = funcDecl->FindModifier<IntrinsicOpModifier>())
             {
-                return lowerIntrinsicCall(expr, intrinsicOpModifier->op);
+                auto op = getIntrinsicOp(funcDecl, intrinsicOpModifier);
+                return lowerIntrinsicCall(expr, op);
                 // 
             }
             // TODO: handle target intrinsic modifier too...
diff --git a/source/slang/modifier-defs.h b/source/slang/modifier-defs.h
index d7d0391e4..9a16a0bdd 100644
--- a/source/slang/modifier-defs.h
+++ b/source/slang/modifier-defs.h
@@ -25,32 +25,28 @@ SIMPLE_MODIFIER(Exported);
 
 #undef SIMPLE_MODIFIER
 
-// Base class for modifiers that mark something as "intrinsic"
-// and thus lacking a direct implementation in the language.
-ABSTRACT_SYNTAX_CLASS(IntrinsicModifierBase, Modifier)
-END_SYNTAX_CLASS()
-
-// A modifier that marks something as one of a small set of
-// truly intrinsic operations that the compiler knows about
-// directly.
-SYNTAX_CLASS(IntrinsicOpModifier, IntrinsicModifierBase)
+// A modifier that marks something as an operation that
+// has a one-to-one translation to the IR, and thus
+// has no direct definition in the high-level language.
+//
+SYNTAX_CLASS(IntrinsicOpModifier, Modifier)
 
-// token that names the intrinsic op
-FIELD(Token, opToken)
+    // token that names the intrinsic op
+    FIELD(Token, opToken)
 
-// The opcode for the intrinsic operation
-FIELD_INIT(IntrinsicOp, op, IntrinsicOp::Unknown)
+    // The opcode for the intrinsic operation
+    FIELD_INIT(IROp, op, kIROp_Nop)
 END_SYNTAX_CLASS()
 
 // A modifier that marks something as an intrinsic function,
 // for some subset of targets.
-SYNTAX_CLASS(TargetIntrinsicModifier, IntrinsicModifierBase)
-// Token that names the target that the operation
-// is an intrisic for.
-FIELD(Token, targetToken)
+SYNTAX_CLASS(TargetIntrinsicModifier, Modifier)
+    // Token that names the target that the operation
+    // is an intrisic for.
+    FIELD(Token, targetToken)
 
-// A custom definition for the operation
-FIELD(Token, definitionToken)
+    // A custom definition for the operation
+    FIELD(Token, definitionToken)
 END_SYNTAX_CLASS()
 
 // A modifier to tag something as an intrinsic that requires
diff --git a/source/slang/parser.cpp b/source/slang/parser.cpp
index 9c0d692e6..8ea41641d 100644
--- a/source/slang/parser.cpp
+++ b/source/slang/parser.cpp
@@ -3766,29 +3766,51 @@ namespace Slang
     {
         RefPtr<IntrinsicOpModifier> modifier = new IntrinsicOpModifier();
 
-        parser->ReadToken(TokenType::LParent);
-        if (parser->LookAheadToken(TokenType::IntegerLiteral))
-        {
-            modifier->op = (IntrinsicOp)StringToInt(parser->ReadToken().Content);
-        }
-        else
+        // We allow a few difference forms here:
+        //
+        // First, we can specify the intrinsic op `enum` value directly:
+        //
+        //     __intrinsic_op(<integer literal>)
+        //
+        // Second, we can specify the operation by name:
+        //
+        //     __intrinsic_op(<identifier>)
+        //
+        // Finally, we can leave off the specification, so that the
+        // op name will be derived fromthe function name:
+        //
+        //     __intrinsic_op
+        //
+        if (AdvanceIf(parser, TokenType::LParent))
         {
-            modifier->opToken = parser->ReadToken(TokenType::Identifier);
+            if (AdvanceIf(parser, TokenType::OpSub))
+            {
+                modifier->op = IROp(-StringToInt(parser->ReadToken().Content));
+            }
+            else if (parser->LookAheadToken(TokenType::IntegerLiteral))
+            {
+                modifier->op = IROp(StringToInt(parser->ReadToken().Content));
+            }
+            else
+            {
+                modifier->opToken = parser->ReadToken(TokenType::Identifier);
 
-            modifier->op = findIntrinsicOp(modifier->opToken.Content.Buffer());
+                modifier->op = findIROp(modifier->opToken.Content.Buffer());
 
-            if (modifier->op == IntrinsicOp::Unknown)
-            {
-                parser->sink->diagnose(modifier->opToken, Diagnostics::unimplemented, "unknown intrinsic op");
+                if (modifier->op == kIROp_Invalid)
+                {
+                    parser->sink->diagnose(modifier->opToken, Diagnostics::unimplemented, "unknown intrinsic op");
+                }
             }
+
+            parser->ReadToken(TokenType::RParent);
         }
 
-        parser->ReadToken(TokenType::RParent);
 
         return modifier;
     }
 
-    static RefPtr<RefObject> parseIntrinsicModifier(Parser* parser, void* /*userData*/)
+    static RefPtr<RefObject> parseTargetIntrinsicModifier(Parser* parser, void* /*userData*/)
     {
         auto modifier = new TargetIntrinsicModifier();
 
@@ -4027,8 +4049,8 @@ namespace Slang
 
         MODIFIER(layout,            parseLayoutModifier);
 
-        MODIFIER(__intrinsic_op,    parseIntrinsicOpModifier);
-        MODIFIER(__intrinsic,       parseIntrinsicModifier);
+        MODIFIER(__intrinsic_op,        parseIntrinsicOpModifier);
+        MODIFIER(__target_intrinsic,    parseTargetIntrinsicModifier);
         MODIFIER(__glsl_extension,  parseGLSLExtensionModifier);
         MODIFIER(__glsl_version,    parseGLSLVersionModifier);
 
diff --git a/source/slang/slang-stdlib.cpp b/source/slang/slang-stdlib.cpp
index afcca4d7f..4d5fd6f87 100644
--- a/source/slang/slang-stdlib.cpp
+++ b/source/slang/slang-stdlib.cpp
@@ -31,8 +31,8 @@ interface __BuiltinFloatingPointType : __BuiltinRealType, __BuiltinSignedArithme
 
 __generic<T,U> __intrinsic_op(Sequence) U operator,(T left, U right);
 
-__generic<T> __intrinsic_op(Select) T operator?:(bool condition, T ifTrue, T ifFalse);
-__generic<T, let N : int> __intrinsic_op(Select) vector<T,N> operator?:(vector<bool,N> condition, vector<T,N> ifTrue, vector<T,N> ifFalse);
+__generic<T> __intrinsic_op(select) T operator?:(bool condition, T ifTrue, T ifFalse);
+__generic<T, let N : int> __intrinsic_op(select) vector<T,N> operator?:(vector<bool,N> condition, vector<T,N> ifTrue, vector<T,N> ifFalse);
 
 )=" };
 
@@ -44,60 +44,60 @@ typedef uint UINT;
 
 __generic<T> __magic_type(HLSLAppendStructuredBufferType) struct AppendStructuredBuffer
 {
-    __intrinsic void Append(T value);
+    __intrinsic_op void Append(T value);
 
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint numStructs,
         out uint stride);
 };
 
 __magic_type(HLSLByteAddressBufferType) struct ByteAddressBuffer
 {
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint dim);
 
-    __intrinsic uint Load(int location);
-    __intrinsic uint Load(int location, out uint status);
+    __intrinsic_op uint Load(int location);
+    __intrinsic_op uint Load(int location, out uint status);
 
-    __intrinsic uint2 Load2(int location);
-    __intrinsic uint2 Load2(int location, out uint status);
+    __intrinsic_op uint2 Load2(int location);
+    __intrinsic_op uint2 Load2(int location, out uint status);
 
-    __intrinsic uint3 Load3(int location);
-    __intrinsic uint3 Load3(int location, out uint status);
+    __intrinsic_op uint3 Load3(int location);
+    __intrinsic_op uint3 Load3(int location, out uint status);
 
-    __intrinsic uint4 Load4(int location);
-    __intrinsic uint4 Load4(int location, out uint status);
+    __intrinsic_op uint4 Load4(int location);
+    __intrinsic_op uint4 Load4(int location, out uint status);
 };
 
 __generic<T> __magic_type(HLSLStructuredBufferType) struct StructuredBuffer
 {
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint numStructs,
         out uint stride);
 
-    __intrinsic T Load(int location);
-    __intrinsic T Load(int location, out uint status);
+    __intrinsic_op T Load(int location);
+    __intrinsic_op T Load(int location, out uint status);
 
-    __intrinsic __subscript(uint index) -> T;
+    __intrinsic_op __subscript(uint index) -> T;
 };
 
 __generic<T> __magic_type(HLSLConsumeStructuredBufferType) struct ConsumeStructuredBuffer
 {
-    __intrinsic T Consume();
+    __intrinsic_op T Consume();
 
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint numStructs,
         out uint stride);
 };
 
 __generic<T, let N : int> __magic_type(HLSLInputPatchType) struct InputPatch
 {
-    __intrinsic __subscript(uint index) -> T;
+    __intrinsic_op __subscript(uint index) -> T;
 };
 
 __generic<T, let N : int> __magic_type(HLSLOutputPatchType) struct OutputPatch
 {
-    __intrinsic __subscript(uint index) -> T { set; }
+    __intrinsic_op __subscript(uint index) -> T { set; }
 };
 
 __magic_type(HLSLRWByteAddressBufferType) struct RWByteAddressBuffer
@@ -105,128 +105,128 @@ __magic_type(HLSLRWByteAddressBufferType) struct RWByteAddressBuffer
     // Note(tfoley): supports alll operations from `ByteAddressBuffer`
     // TODO(tfoley): can this be made a sub-type?
 
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint dim);
 
-    __intrinsic uint Load(int location);
-    __intrinsic uint Load(int location, out uint status);
+    __intrinsic_op uint Load(int location);
+    __intrinsic_op uint Load(int location, out uint status);
 
-    __intrinsic uint2 Load2(int location);
-    __intrinsic uint2 Load2(int location, out uint status);
+    __intrinsic_op uint2 Load2(int location);
+    __intrinsic_op uint2 Load2(int location, out uint status);
 
-    __intrinsic uint3 Load3(int location);
-    __intrinsic uint3 Load3(int location, out uint status);
+    __intrinsic_op uint3 Load3(int location);
+    __intrinsic_op uint3 Load3(int location, out uint status);
 
-    __intrinsic uint4 Load4(int location);
-    __intrinsic uint4 Load4(int location, out uint status);
+    __intrinsic_op uint4 Load4(int location);
+    __intrinsic_op uint4 Load4(int location, out uint status);
 
     // Added operations:
 
-    __intrinsic void InterlockedAdd(
+    __intrinsic_op void InterlockedAdd(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedAdd(
+    __intrinsic_op void InterlockedAdd(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedAnd(
+    __intrinsic_op void InterlockedAnd(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedAnd(
+    __intrinsic_op void InterlockedAnd(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedCompareExchange(
+    __intrinsic_op void InterlockedCompareExchange(
         UINT dest,
         UINT compare_value,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedCompareExchange(
+    __intrinsic_op void InterlockedCompareExchange(
         UINT dest,
         UINT compare_value,
         UINT value);
 
-    __intrinsic void InterlockedCompareStore(
+    __intrinsic_op void InterlockedCompareStore(
         UINT dest,
         UINT compare_value,
         UINT value);
-    __intrinsic void InterlockedCompareStore(
+    __intrinsic_op void InterlockedCompareStore(
         UINT dest,
         UINT compare_value);
 
-    __intrinsic void InterlockedExchange(
+    __intrinsic_op void InterlockedExchange(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedExchange(
+    __intrinsic_op void InterlockedExchange(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedMax(
+    __intrinsic_op void InterlockedMax(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedMax(
+    __intrinsic_op void InterlockedMax(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedMin(
+    __intrinsic_op void InterlockedMin(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedMin(
+    __intrinsic_op void InterlockedMin(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedOr(
+    __intrinsic_op void InterlockedOr(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedOr(
+    __intrinsic_op void InterlockedOr(
         UINT dest,
         UINT value);
 
-    __intrinsic void InterlockedXor(
+    __intrinsic_op void InterlockedXor(
         UINT dest,
         UINT value,
         out UINT original_value);
-    __intrinsic void InterlockedXor(
+    __intrinsic_op void InterlockedXor(
         UINT dest,
         UINT value);
 
-    __intrinsic void Store(
+    __intrinsic_op void Store(
         uint address,
         uint value);
 
-    __intrinsic void Store2(
+    __intrinsic_op void Store2(
         uint address,
         uint2 value);
 
-    __intrinsic void Store3(
+    __intrinsic_op void Store3(
         uint address,
         uint3 value);
 
-    __intrinsic void Store4(
+    __intrinsic_op void Store4(
         uint address,
         uint4 value);
 };
 
 __generic<T> __magic_type(HLSLRWStructuredBufferType) struct RWStructuredBuffer
 {
-    __intrinsic uint DecrementCounter();
+    __intrinsic_op uint DecrementCounter();
 
-    __intrinsic void GetDimensions(
+    __intrinsic_op void GetDimensions(
         out uint numStructs,
         out uint stride);
 
-    __intrinsic void IncrementCounter();
+    __intrinsic_op void IncrementCounter();
 
-    __intrinsic T Load(int location);
-    __intrinsic T Load(int location, out uint status);
+    __intrinsic_op T Load(int location);
+    __intrinsic_op T Load(int location, out uint status);
 
-    __intrinsic __subscript(uint index) -> T { get; set; }
+    __intrinsic_op __subscript(uint index) -> T { get; set; }
 };
 
 __generic<T> __magic_type(HLSLPointStreamType) struct PointStream
@@ -252,566 +252,566 @@ __generic<T> __magic_type(HLSLTriangleStreamType) struct TriangleStream
 // Note(tfoley): Trying to systematically add all the HLSL builtins
 
 // Try to terminate the current draw or dispatch call (HLSL SM 4.0)
-__intrinsic void abort();
+__intrinsic_op void abort();
 
 // Absolute value (HLSL SM 1.0)
-__generic<T : __BuiltinSignedArithmeticType> __intrinsic T abs(T x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int> __intrinsic vector<T,N> abs(vector<T,N> x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> abs(matrix<T,N,M> x);
+__generic<T : __BuiltinSignedArithmeticType> __intrinsic_op T abs(T x);
+__generic<T : __BuiltinSignedArithmeticType, let N : int> __intrinsic_op vector<T,N> abs(vector<T,N> x);
+__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> abs(matrix<T,N,M> x);
 
 // Inverse cosine (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T acos(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> acos(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> acos(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T acos(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> acos(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> acos(matrix<T,N,M> x);
 
 // Test if all components are non-zero (HLSL SM 1.0)
-__generic<T : __BuiltinType> __intrinsic T all(T x);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> all(vector<T,N> x);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> all(matrix<T,N,M> x);
+__generic<T : __BuiltinType> __intrinsic_op T all(T x);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> all(vector<T,N> x);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> all(matrix<T,N,M> x);
 
 // Barrier for writes to all memory spaces (HLSL SM 5.0)
-__intrinsic void AllMemoryBarrier();
+__intrinsic_op void AllMemoryBarrier();
 
 // Thread-group sync and barrier for writes to all memory spaces (HLSL SM 5.0)
-__intrinsic void AllMemoryBarrierWithGroupSync();
+__intrinsic_op void AllMemoryBarrierWithGroupSync();
 
 // Test if any components is non-zero (HLSL SM 1.0)
-__generic<T : __BuiltinType> __intrinsic T any(T x);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> any(vector<T,N> x);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> any(matrix<T,N,M> x);
+__generic<T : __BuiltinType> __intrinsic_op T any(T x);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> any(vector<T,N> x);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> any(matrix<T,N,M> x);
 
 
 // Reinterpret bits as a double (HLSL SM 5.0)
-__intrinsic double asdouble(uint lowbits, uint highbits);
+__intrinsic_op double asdouble(uint lowbits, uint highbits);
 
 // Reinterpret bits as a float (HLSL SM 4.0)
-__intrinsic float asfloat( int x);
-__intrinsic float asfloat(uint x);
-__generic<let N : int> __intrinsic vector<float,N> asfloat(vector< int,N> x);
-__generic<let N : int> __intrinsic vector<float,N> asfloat(vector<uint,N> x);
-__generic<let N : int, let M : int> __intrinsic matrix<float,N,M> asfloat(matrix< int,N,M> x);
-__generic<let N : int, let M : int> __intrinsic matrix<float,N,M> asfloat(matrix<uint,N,M> x);
+__intrinsic_op float asfloat( int x);
+__intrinsic_op float asfloat(uint x);
+__generic<let N : int> __intrinsic_op vector<float,N> asfloat(vector< int,N> x);
+__generic<let N : int> __intrinsic_op vector<float,N> asfloat(vector<uint,N> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<float,N,M> asfloat(matrix< int,N,M> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<float,N,M> asfloat(matrix<uint,N,M> x);
 
 
 // Inverse sine (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T asin(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> asin(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> asin(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T asin(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> asin(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> asin(matrix<T,N,M> x);
 
 // Reinterpret bits as an int (HLSL SM 4.0)
-__intrinsic int asint(float x);
-__intrinsic int asint(uint x);
-__generic<let N : int> __intrinsic vector<int,N> asint(vector<float,N> x);
-__generic<let N : int> __intrinsic vector<int,N> asint(vector<uint,N> x);
-__generic<let N : int, let M : int> __intrinsic matrix<int,N,M> asint(matrix<float,N,M> x);
-__generic<let N : int, let M : int> __intrinsic matrix<int,N,M> asint(matrix<uint,N,M> x);
+__intrinsic_op int asint(float x);
+__intrinsic_op int asint(uint x);
+__generic<let N : int> __intrinsic_op vector<int,N> asint(vector<float,N> x);
+__generic<let N : int> __intrinsic_op vector<int,N> asint(vector<uint,N> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<int,N,M> asint(matrix<float,N,M> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<int,N,M> asint(matrix<uint,N,M> x);
 
 // Reinterpret bits of double as a uint (HLSL SM 5.0)
-__intrinsic void asuint(double value, out uint lowbits, out uint highbits);
+__intrinsic_op void asuint(double value, out uint lowbits, out uint highbits);
 
 // Reinterpret bits as a uint (HLSL SM 4.0)
-__intrinsic uint asuint(float x);
-__intrinsic uint asuint(int x);
-__generic<let N : int> __intrinsic vector<uint,N> asuint(vector<float,N> x);
-__generic<let N : int> __intrinsic vector<uint,N> asuint(vector<int,N> x);
-__generic<let N : int, let M : int> __intrinsic matrix<uint,N,M> asuint(matrix<float,N,M> x);
-__generic<let N : int, let M : int> __intrinsic matrix<uint,N,M> asuint(matrix<int,N,M> x);
+__intrinsic_op uint asuint(float x);
+__intrinsic_op uint asuint(int x);
+__generic<let N : int> __intrinsic_op vector<uint,N> asuint(vector<float,N> x);
+__generic<let N : int> __intrinsic_op vector<uint,N> asuint(vector<int,N> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<uint,N,M> asuint(matrix<float,N,M> x);
+__generic<let N : int, let M : int> __intrinsic_op matrix<uint,N,M> asuint(matrix<int,N,M> x);
 
 // Inverse tangent (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T atan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> atan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> atan(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T atan(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> atan(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> atan(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl,"atan($0,$1)")
-__intrinsic
+__target_intrinsic(glsl,"atan($0,$1)")
+__intrinsic_op
 T atan2(T y, T x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl,"atan($0,$1)")
-__intrinsic
+__target_intrinsic(glsl,"atan($0,$1)")
+__intrinsic_op
 vector<T,N> atan2(vector<T,N> y, vector<T,N> x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl,"atan($0,$1)")
-__intrinsic
+__target_intrinsic(glsl,"atan($0,$1)")
+__intrinsic_op
 matrix<T,N,M> atan2(matrix<T,N,M> y, matrix<T,N,M> x);
 
 // Ceiling (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T ceil(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> ceil(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> ceil(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T ceil(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> ceil(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> ceil(matrix<T,N,M> x);
 
 
 // Check access status to tiled resource
-__intrinsic bool CheckAccessFullyMapped(uint status);
+__intrinsic_op bool CheckAccessFullyMapped(uint status);
 
 // Clamp (HLSL SM 1.0)
-__generic<T : __BuiltinArithmeticType> __intrinsic T clamp(T x, T min, T max);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> clamp(vector<T,N> x, vector<T,N> min, vector<T,N> max);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> clamp(matrix<T,N,M> x, matrix<T,N,M> min, matrix<T,N,M> max);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T clamp(T x, T min, T max);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> clamp(vector<T,N> x, vector<T,N> min, vector<T,N> max);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> clamp(matrix<T,N,M> x, matrix<T,N,M> min, matrix<T,N,M> max);
 
 // Clip (discard) fragment conditionally
-__generic<T : __BuiltinFloatingPointType> __intrinsic void clip(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic void clip(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic void clip(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op void clip(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op void clip(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op void clip(matrix<T,N,M> x);
 
 // Cosine
-__generic<T : __BuiltinFloatingPointType> __intrinsic T cos(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> cos(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> cos(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T cos(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> cos(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> cos(matrix<T,N,M> x);
 
 // Hyperbolic cosine
-__generic<T : __BuiltinFloatingPointType> __intrinsic T cosh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> cosh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> cosh(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T cosh(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> cosh(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> cosh(matrix<T,N,M> x);
 
 // Population count
-__intrinsic uint countbits(uint value);
+__intrinsic_op uint countbits(uint value);
 
 // Cross product
-__generic<T : __BuiltinArithmeticType> __intrinsic vector<T,3> cross(vector<T,3> x, vector<T,3> y);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op vector<T,3> cross(vector<T,3> x, vector<T,3> y);
 
 // Convert encoded color
-__intrinsic int4 D3DCOLORtoUBYTE4(float4 x);
+__intrinsic_op int4 D3DCOLORtoUBYTE4(float4 x);
 
 // Partial-difference derivatives
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl, dFdx)
-__intrinsic
+__target_intrinsic(glsl, dFdx)
+__intrinsic_op
 T ddx(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl, dFdx)
-__intrinsic
+__target_intrinsic(glsl, dFdx)
+__intrinsic_op
 vector<T,N> ddx(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl, dFdx)
-__intrinsic
+__target_intrinsic(glsl, dFdx)
+__intrinsic_op
 matrix<T,N,M> ddx(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdxCoarse)
+__intrinsic_op
 T ddx_coarse(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdxCoarse)
+__intrinsic_op
 vector<T,N> ddx_coarse(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdxCoarse)
+__intrinsic_op
 matrix<T,N,M> ddx_coarse(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxFine)
-__intrinsic
+__target_intrinsic(glsl, dFdxFine)
+__intrinsic_op
 T ddx_fine(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxFine)
-__intrinsic
+__target_intrinsic(glsl, dFdxFine)
+__intrinsic_op
 vector<T,N> ddx_fine(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdxFine)
-__intrinsic
+__target_intrinsic(glsl, dFdxFine)
+__intrinsic_op
 matrix<T,N,M> ddx_fine(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl, dFdy)
-__intrinsic
+__target_intrinsic(glsl, dFdy)
+__intrinsic_op
 T ddy(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl, dFdy)
-__intrinsic
+__target_intrinsic(glsl, dFdy)
+__intrinsic_op
 vector<T,N> ddy(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl, dFdy)
-__intrinsic
+__target_intrinsic(glsl, dFdy)
+__intrinsic_op
  matrix<T,N,M> ddy(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdyCoarse)
+__intrinsic_op
 T ddy_coarse(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdyCoarse)
+__intrinsic_op
 vector<T,N> ddy_coarse(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyCoarse)
-__intrinsic
+__target_intrinsic(glsl, dFdyCoarse)
+__intrinsic_op
 matrix<T,N,M> ddy_coarse(matrix<T,N,M> x);
 
 __generic<T : __BuiltinFloatingPointType>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyFine)
-__intrinsic
+__target_intrinsic(glsl, dFdyFine)
+__intrinsic_op
 T ddy_fine(T x);
 __generic<T : __BuiltinFloatingPointType, let N : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyFine)
-__intrinsic
+__target_intrinsic(glsl, dFdyFine)
+__intrinsic_op
 vector<T,N> ddy_fine(vector<T,N> x);
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
 __glsl_extension(GL_ARB_derivative_control)
-__intrinsic(glsl, dFdyFine)
-__intrinsic
+__target_intrinsic(glsl, dFdyFine)
+__intrinsic_op
 matrix<T,N,M> ddy_fine(matrix<T,N,M> x);
 
 
 // Radians to degrees
-__generic<T : __BuiltinFloatingPointType> __intrinsic T degrees(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> degrees(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> degrees(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T degrees(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> degrees(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> degrees(matrix<T,N,M> x);
 
 // Matrix determinant
 
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic T determinant(matrix<T,N,N> m);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op T determinant(matrix<T,N,N> m);
 
 // Barrier for device memory
-__intrinsic void DeviceMemoryBarrier();
-__intrinsic void DeviceMemoryBarrierWithGroupSync();
+__intrinsic_op void DeviceMemoryBarrier();
+__intrinsic_op void DeviceMemoryBarrierWithGroupSync();
 
 // Vector distance
 
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic T distance(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op T distance(vector<T,N> x, vector<T,N> y);
 
 // Vector dot product
 
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic T dot(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op T dot(vector<T,N> x, vector<T,N> y);
 
 // Helper for computing distance terms for lighting (obsolete)
 
-__generic<T : __BuiltinFloatingPointType> __intrinsic vector<T,4> dst(vector<T,4> x, vector<T,4> y);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op vector<T,4> dst(vector<T,4> x, vector<T,4> y);
 
 // Error message
 
-// __intrinsic void errorf( string format, ... );
+// __intrinsic_op void errorf( string format, ... );
 
 // Attribute evaluation
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T EvaluateAttributeAtCentroid(T x);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> EvaluateAttributeAtCentroid(vector<T,N> x);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> EvaluateAttributeAtCentroid(matrix<T,N,M> x);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T EvaluateAttributeAtCentroid(T x);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> EvaluateAttributeAtCentroid(vector<T,N> x);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> EvaluateAttributeAtCentroid(matrix<T,N,M> x);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T EvaluateAttributeAtSample(T x, uint sampleindex);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> EvaluateAttributeAtSample(vector<T,N> x, uint sampleindex);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> EvaluateAttributeAtSample(matrix<T,N,M> x, uint sampleindex);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T EvaluateAttributeAtSample(T x, uint sampleindex);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> EvaluateAttributeAtSample(vector<T,N> x, uint sampleindex);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> EvaluateAttributeAtSample(matrix<T,N,M> x, uint sampleindex);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T EvaluateAttributeSnapped(T x, int2 offset);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> EvaluateAttributeSnapped(vector<T,N> x, int2 offset);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> EvaluateAttributeSnapped(matrix<T,N,M> x, int2 offset);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T EvaluateAttributeSnapped(T x, int2 offset);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> EvaluateAttributeSnapped(vector<T,N> x, int2 offset);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> EvaluateAttributeSnapped(matrix<T,N,M> x, int2 offset);
 
 // Base-e exponent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T exp(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> exp(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> exp(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T exp(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> exp(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> exp(matrix<T,N,M> x);
 
 // Base-2 exponent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T exp2(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> exp2(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> exp2(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T exp2(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> exp2(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> exp2(matrix<T,N,M> x);
 
 // Convert 16-bit float stored in low bits of integer
-__intrinsic float f16tof32(uint value);
-__generic<let N : int> __intrinsic vector<float,N> f16tof32(vector<uint,N> value);
+__intrinsic_op float f16tof32(uint value);
+__generic<let N : int> __intrinsic_op vector<float,N> f16tof32(vector<uint,N> value);
 
 // Convert to 16-bit float stored in low bits of integer
-__intrinsic uint f32tof16(float value);
-__generic<let N : int> __intrinsic vector<uint,N> f32tof16(vector<float,N> value);
+__intrinsic_op uint f32tof16(float value);
+__generic<let N : int> __intrinsic_op vector<uint,N> f32tof16(vector<float,N> value);
 
 // Flip surface normal to face forward, if needed
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> faceforward(vector<T,N> n, vector<T,N> i, vector<T,N> ng);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> faceforward(vector<T,N> n, vector<T,N> i, vector<T,N> ng);
 
 // Find first set bit starting at high bit and working down
-__intrinsic int firstbithigh(int value);
-__generic<let N : int> __intrinsic vector<int,N> firstbithigh(vector<int,N> value);
+__intrinsic_op int firstbithigh(int value);
+__generic<let N : int> __intrinsic_op vector<int,N> firstbithigh(vector<int,N> value);
 
-__intrinsic uint firstbithigh(uint value);
-__generic<let N : int> __intrinsic vector<uint,N> firstbithigh(vector<uint,N> value);
+__intrinsic_op uint firstbithigh(uint value);
+__generic<let N : int> __intrinsic_op vector<uint,N> firstbithigh(vector<uint,N> value);
 
 // Find first set bit starting at low bit and working up
-__intrinsic int firstbitlow(int value);
-__generic<let N : int> __intrinsic vector<int,N> firstbitlow(vector<int,N> value);
+__intrinsic_op int firstbitlow(int value);
+__generic<let N : int> __intrinsic_op vector<int,N> firstbitlow(vector<int,N> value);
 
-__intrinsic uint firstbitlow(uint value);
-__generic<let N : int> __intrinsic vector<uint,N> firstbitlow(vector<uint,N> value);
+__intrinsic_op uint firstbitlow(uint value);
+__generic<let N : int> __intrinsic_op vector<uint,N> firstbitlow(vector<uint,N> value);
 
 // Floor (HLSL SM 1.0)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T floor(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> floor(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> floor(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T floor(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> floor(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> floor(matrix<T,N,M> x);
 
 // Fused multiply-add for doubles
-__intrinsic double fma(double a, double b, double c);
-__generic<let N : int> __intrinsic vector<double, N> fma(vector<double, N> a, vector<double, N> b, vector<double, N> c);
-__generic<let N : int, let M : int> __intrinsic matrix<double,N,M> fma(matrix<double,N,M> a, matrix<double,N,M> b, matrix<double,N,M> c);
+__intrinsic_op double fma(double a, double b, double c);
+__generic<let N : int> __intrinsic_op vector<double, N> fma(vector<double, N> a, vector<double, N> b, vector<double, N> c);
+__generic<let N : int, let M : int> __intrinsic_op matrix<double,N,M> fma(matrix<double,N,M> a, matrix<double,N,M> b, matrix<double,N,M> c);
 
 // Floating point remainder of x/y
-__generic<T : __BuiltinFloatingPointType> __intrinsic T fmod(T x, T y);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> fmod(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> fmod(matrix<T,N,M> x, matrix<T,N,M> y);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T fmod(T x, T y);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> fmod(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> fmod(matrix<T,N,M> x, matrix<T,N,M> y);
 
 // Fractional part
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl, fract)
-__intrinsic
+__target_intrinsic(glsl, fract)
+__intrinsic_op
 T frac(T x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl, fract)
-__intrinsic
+__target_intrinsic(glsl, fract)
+__intrinsic_op
 vector<T,N> frac(vector<T,N> x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl, fract)
-__intrinsic
+__target_intrinsic(glsl, fract)
+__intrinsic_op
 matrix<T,N,M> frac(matrix<T,N,M> x);
 
 // Split float into mantissa and exponent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T frexp(T x, out T exp);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> frexp(vector<T,N> x, out vector<T,N> exp);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> frexp(matrix<T,N,M> x, out matrix<T,N,M> exp);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T frexp(T x, out T exp);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> frexp(vector<T,N> x, out vector<T,N> exp);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> frexp(matrix<T,N,M> x, out matrix<T,N,M> exp);
 
 // Texture filter width
-__generic<T : __BuiltinFloatingPointType> __intrinsic T fwidth(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> fwidth(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> fwidth(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T fwidth(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> fwidth(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> fwidth(matrix<T,N,M> x);
 
 )=", R"=(
 
 // Get number of samples in render target
-__intrinsic uint GetRenderTargetSampleCount();
+__intrinsic_op uint GetRenderTargetSampleCount();
 
 // Get position of given sample
-__intrinsic float2 GetRenderTargetSamplePosition(int Index);
+__intrinsic_op float2 GetRenderTargetSamplePosition(int Index);
 
 // Group memory barrier
-__intrinsic void GroupMemoryBarrier();
-__intrinsic void GroupMemoryBarrierWithGroupSync();
+__intrinsic_op void GroupMemoryBarrier();
+__intrinsic_op void GroupMemoryBarrierWithGroupSync();
 
 // Atomics
-__intrinsic void InterlockedAdd(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedAdd(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedAdd(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedAdd(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedAnd(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedAnd(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedAnd(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedAnd(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedCompareExchange(in out  int dest,  int compare_value,  int value, out  int original_value);
-__intrinsic void InterlockedCompareExchange(in out uint dest, uint compare_value, uint value, out uint original_value);
+__intrinsic_op void InterlockedCompareExchange(in out  int dest,  int compare_value,  int value, out  int original_value);
+__intrinsic_op void InterlockedCompareExchange(in out uint dest, uint compare_value, uint value, out uint original_value);
 
-__intrinsic void InterlockedCompareStore(in out  int dest,  int compare_value,  int value);
-__intrinsic void InterlockedCompareStore(in out uint dest, uint compare_value, uint value);
+__intrinsic_op void InterlockedCompareStore(in out  int dest,  int compare_value,  int value);
+__intrinsic_op void InterlockedCompareStore(in out uint dest, uint compare_value, uint value);
 
-__intrinsic void InterlockedExchange(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedExchange(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedExchange(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedExchange(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedMax(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedMax(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedMax(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedMax(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedMin(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedMin(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedMin(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedMin(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedOr(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedOr(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedOr(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedOr(in out uint dest, uint value, out uint original_value);
 
-__intrinsic void InterlockedXor(in out  int dest,  int value, out  int original_value);
-__intrinsic void InterlockedXor(in out uint dest, uint value, out uint original_value);
+__intrinsic_op void InterlockedXor(in out  int dest,  int value, out  int original_value);
+__intrinsic_op void InterlockedXor(in out uint dest, uint value, out uint original_value);
 
 // Is floating-point value finite?
-__generic<T : __BuiltinFloatingPointType> __intrinsic bool isfinite(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<bool,N> isfinite(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<bool,N,M> isfinite(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op bool isfinite(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<bool,N> isfinite(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<bool,N,M> isfinite(matrix<T,N,M> x);
 
 // Is floating-point value infinite?
-__generic<T : __BuiltinFloatingPointType> __intrinsic bool isinf(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<bool,N> isinf(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<bool,N,M> isinf(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op bool isinf(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<bool,N> isinf(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<bool,N,M> isinf(matrix<T,N,M> x);
 
 // Is floating-point value not-a-number?
-__generic<T : __BuiltinFloatingPointType> __intrinsic bool isnan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<bool,N> isnan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<bool,N,M> isnan(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op bool isnan(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<bool,N> isnan(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<bool,N,M> isnan(matrix<T,N,M> x);
 
 // Construct float from mantissa and exponent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T ldexp(T x, T exp);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> ldexp(vector<T,N> x, vector<T,N> exp);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> ldexp(matrix<T,N,M> x, matrix<T,N,M> exp);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T ldexp(T x, T exp);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> ldexp(vector<T,N> x, vector<T,N> exp);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> ldexp(matrix<T,N,M> x, matrix<T,N,M> exp);
 
 // Vector length
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic T length(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op T length(vector<T,N> x);
 
 // Linear interpolation
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl, mix)
-__intrinsic
+__target_intrinsic(glsl, mix)
+__intrinsic_op
 T lerp(T x, T y, T s);
 
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl, mix)
-__intrinsic
+__target_intrinsic(glsl, mix)
+__intrinsic_op
 vector<T,N> lerp(vector<T,N> x, vector<T,N> y, vector<T,N> s);
 
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl, mix)
-__intrinsic
+__target_intrinsic(glsl, mix)
+__intrinsic_op
 matrix<T,N,M> lerp(matrix<T,N,M> x, matrix<T,N,M> y, matrix<T,N,M> s);
 
 // Legacy lighting function (obsolete)
-__intrinsic float4 lit(float n_dot_l, float n_dot_h, float m);
+__intrinsic_op float4 lit(float n_dot_l, float n_dot_h, float m);
 
 // Base-e logarithm
-__generic<T : __BuiltinFloatingPointType> __intrinsic T log(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> log(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> log(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T log(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> log(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> log(matrix<T,N,M> x);
 
 // Base-10 logarithm
-__generic<T : __BuiltinFloatingPointType> __intrinsic T log10(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> log10(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> log10(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T log10(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> log10(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> log10(matrix<T,N,M> x);
 
 // Base-2 logarithm
-__generic<T : __BuiltinFloatingPointType> __intrinsic T log2(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> log2(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> log2(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T log2(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> log2(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> log2(matrix<T,N,M> x);
 
 // multiply-add
-__generic<T : __BuiltinArithmeticType> __intrinsic T mad(T mvalue, T avalue, T bvalue);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> mad(vector<T,N> mvalue, vector<T,N> avalue, vector<T,N> bvalue);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> mad(matrix<T,N,M> mvalue, matrix<T,N,M> avalue, matrix<T,N,M> bvalue);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T mad(T mvalue, T avalue, T bvalue);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> mad(vector<T,N> mvalue, vector<T,N> avalue, vector<T,N> bvalue);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> mad(matrix<T,N,M> mvalue, matrix<T,N,M> avalue, matrix<T,N,M> bvalue);
 
 // maximum
-__generic<T : __BuiltinArithmeticType> __intrinsic T max(T x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> max(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> max(matrix<T,N,M> x, matrix<T,N,M> y);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T max(T x, T y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> max(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> max(matrix<T,N,M> x, matrix<T,N,M> y);
 
 // minimum
-__generic<T : __BuiltinArithmeticType> __intrinsic T min(T x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> min(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> min(matrix<T,N,M> x, matrix<T,N,M> y);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T min(T x, T y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> min(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> min(matrix<T,N,M> x, matrix<T,N,M> y);
 
 // split into integer and fractional parts (both with same sign)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T modf(T x, out T ip);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> modf(vector<T,N> x, out vector<T,N> ip);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> modf(matrix<T,N,M> x, out matrix<T,N,M> ip);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T modf(T x, out T ip);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> modf(vector<T,N> x, out vector<T,N> ip);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> modf(matrix<T,N,M> x, out matrix<T,N,M> ip);
 
 // msad4 (whatever that is)
-__intrinsic uint4 msad4(uint reference, uint2 source, uint4 accum);
+__intrinsic_op uint4 msad4(uint reference, uint2 source, uint4 accum);
 
 // General inner products
 
 // scalar-scalar
-__generic<T : __BuiltinArithmeticType> __intrinsic_op(Mul_Scalar_Scalar) T mul(T x, T y);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T mul(T x, T y);
 
 // scalar-vector and vector-scalar
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(Mul_Vector_Scalar) vector<T,N> mul(vector<T,N> x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(Mul_Scalar_Vector) vector<T,N> mul(T x, vector<T,N> y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> mul(vector<T,N> x, T y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> mul(T x, vector<T,N> y);
 
 // scalar-matrix and matrix-scalar
-__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(Mul_Matrix_Scalar) matrix<T,N,M> mul(matrix<T,N,M> x, T y);
-__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(Mul_Scalar_Matrix) matrix<T,N,M> mul(T x, matrix<T,N,M> y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op matrix<T,N,M> mul(matrix<T,N,M> x, T y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op matrix<T,N,M> mul(T x, matrix<T,N,M> y);
 
 // vector-vector (dot product)
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(InnerProduct_Vector_Vector) T mul(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(dot) T mul(vector<T,N> x, vector<T,N> y);
 
 // vector-matrix
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(InnerProduct_Vector_Matrix) vector<T,M> mul(vector<T,N> x, matrix<T,N,M> y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulVectorMatrix) vector<T,M> mul(vector<T,N> x, matrix<T,N,M> y);
 
 // matrix-vector
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(InnerProduct_Matrix_Vector) vector<T,N> mul(matrix<T,N,M> x, vector<T,M> y);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulMatrixVector) vector<T,N> mul(matrix<T,N,M> x, vector<T,M> y);
 
 // matrix-matrix
-__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(InnerProduct_Matrix_Matrix) matrix<T,R,C> mul(matrix<T,R,N> x, matrix<T,N,C> y);
+__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(mulMatrixMatrix) matrix<T,R,C> mul(matrix<T,R,N> x, matrix<T,N,C> y);
 
 // noise (deprecated)
-__intrinsic float noise(float x);
-__generic<let N : int> __intrinsic float noise(vector<float, N> x);
+__intrinsic_op float noise(float x);
+__generic<let N : int> __intrinsic_op float noise(vector<float, N> x);
 
 // Normalize a vector
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> normalize(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> normalize(vector<T,N> x);
 
 // Raise to a power
-__generic<T : __BuiltinFloatingPointType> __intrinsic T pow(T x, T y);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> pow(vector<T,N> x, vector<T,N> y);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> pow(matrix<T,N,M> x, matrix<T,N,M> y);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T pow(T x, T y);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> pow(vector<T,N> x, vector<T,N> y);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> pow(matrix<T,N,M> x, matrix<T,N,M> y);
 
 // Output message
 
-// __intrinsic void printf( string format, ... );
+// __intrinsic_op void printf( string format, ... );
 
 // Tessellation factor fixup routines
 
-__intrinsic void Process2DQuadTessFactorsAvg(
+__intrinsic_op void Process2DQuadTessFactorsAvg(
     in  float4 RawEdgeFactors,
     in  float2 InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void Process2DQuadTessFactorsMax(
+__intrinsic_op void Process2DQuadTessFactorsMax(
     in  float4 RawEdgeFactors,
     in  float2 InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void Process2DQuadTessFactorsMin(
+__intrinsic_op void Process2DQuadTessFactorsMin(
     in  float4 RawEdgeFactors,
     in  float2 InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void ProcessIsolineTessFactors(
+__intrinsic_op void ProcessIsolineTessFactors(
     in  float RawDetailFactor,
     in  float RawDensityFactor,
     out float RoundedDetailFactor,
     out float RoundedDensityFactor);
 
-__intrinsic void ProcessQuadTessFactorsAvg(
+__intrinsic_op void ProcessQuadTessFactorsAvg(
     in  float4 RawEdgeFactors,
     in  float InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void ProcessQuadTessFactorsMax(
+__intrinsic_op void ProcessQuadTessFactorsMax(
     in  float4 RawEdgeFactors,
     in  float InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void ProcessQuadTessFactorsMin(
+__intrinsic_op void ProcessQuadTessFactorsMin(
     in  float4 RawEdgeFactors,
     in  float InsideScale,
     out float4 RoundedEdgeTessFactors,
     out float2 RoundedInsideTessFactors,
     out float2 UnroundedInsideTessFactors);
 
-__intrinsic void ProcessTriTessFactorsAvg(
+__intrinsic_op void ProcessTriTessFactorsAvg(
     in  float3 RawEdgeFactors,
     in  float InsideScale,
     out float3 RoundedEdgeTessFactors,
     out float RoundedInsideTessFactor,
     out float UnroundedInsideTessFactor);
 
-__intrinsic void ProcessTriTessFactorsMax(
+__intrinsic_op void ProcessTriTessFactorsMax(
     in  float3 RawEdgeFactors,
     in  float InsideScale,
     out float3 RoundedEdgeTessFactors,
     out float RoundedInsideTessFactor,
     out float UnroundedInsideTessFactor);
 
-__intrinsic void ProcessTriTessFactorsMin(
+__intrinsic_op void ProcessTriTessFactorsMin(
     in  float3 RawEdgeFactors,
     in  float InsideScale,
     out float3 RoundedEdgeTessFactors,
@@ -819,191 +819,191 @@ __intrinsic void ProcessTriTessFactorsMin(
     out float UnroundedInsideTessFactors);
 
 // Degrees to radians
-__generic<T : __BuiltinFloatingPointType> __intrinsic T radians(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> radians(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> radians(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T radians(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> radians(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> radians(matrix<T,N,M> x);
 
 // Approximate reciprocal
-__generic<T : __BuiltinFloatingPointType> __intrinsic T rcp(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> rcp(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> rcp(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T rcp(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> rcp(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> rcp(matrix<T,N,M> x);
 
 // Reflect incident vector across plane with given normal
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic
+__intrinsic_op
 vector<T,N> reflect(vector<T,N> i, vector<T,N> n);
 
 // Refract incident vector given surface normal and index of refraction
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic
+__intrinsic_op
 vector<T,N> refract(vector<T,N> i, vector<T,N> n, float eta);
 
 // Reverse order of bits
-__intrinsic uint reversebits(uint value);
+__intrinsic_op uint reversebits(uint value);
 __generic<let N : int> vector<uint,N> reversebits(vector<uint,N> value);
 
 // Round-to-nearest
-__generic<T : __BuiltinFloatingPointType> __intrinsic T round(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> round(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> round(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T round(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> round(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> round(matrix<T,N,M> x);
 
 // Reciprocal of square root
-__generic<T : __BuiltinFloatingPointType> __intrinsic T rsqrt(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> rsqrt(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> rsqrt(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T rsqrt(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> rsqrt(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> rsqrt(matrix<T,N,M> x);
 
 // Clamp value to [0,1] range
 __generic<T : __BuiltinFloatingPointType>
-__intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic
+__target_intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic_op
 T saturate(T x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int>
-__intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic
+__target_intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic_op
 vector<T,N> saturate(vector<T,N> x);
 
 __generic<T : __BuiltinFloatingPointType, let N : int, let M : int>
-__intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic
+__target_intrinsic(glsl, "clamp($0, 0, 1)") __intrinsic_op
 matrix<T,N,M> saturate(matrix<T,N,M> x);
 
 
 // Extract sign of value
-__generic<T : __BuiltinSignedArithmeticType> __intrinsic int sign(T x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int> __intrinsic vector<int,N> sign(vector<T,N> x);
-__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> __intrinsic matrix<int,N,M> sign(matrix<T,N,M> x);
+__generic<T : __BuiltinSignedArithmeticType> __intrinsic_op int sign(T x);
+__generic<T : __BuiltinSignedArithmeticType, let N : int> __intrinsic_op vector<int,N> sign(vector<T,N> x);
+__generic<T : __BuiltinSignedArithmeticType, let N : int, let M : int> __intrinsic_op matrix<int,N,M> sign(matrix<T,N,M> x);
 
 )=", R"=(
 
 
 // Sine
-__generic<T : __BuiltinFloatingPointType> __intrinsic T sin(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> sin(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> sin(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T sin(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> sin(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> sin(matrix<T,N,M> x);
 
 // Sine and cosine
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic void sincos(T x, out T s, out T c);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic void sincos(vector<T,N> x, out vector<T,N> s, out vector<T,N> c);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic void sincos(matrix<T,N,M> x, out matrix<T,N,M> s, out matrix<T,N,M> c);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op void sincos(T x, out T s, out T c);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op void sincos(vector<T,N> x, out vector<T,N> s, out vector<T,N> c);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op void sincos(matrix<T,N,M> x, out matrix<T,N,M> s, out matrix<T,N,M> c);
 
 // Hyperbolic Sine
-__generic<T : __BuiltinFloatingPointType> __intrinsic T sinh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> sinh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> sinh(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T sinh(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> sinh(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> sinh(matrix<T,N,M> x);
 
 // Smooth step (Hermite interpolation)
-__generic<T : __BuiltinFloatingPointType> __intrinsic T smoothstep(T min, T max, T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> smoothstep(vector<T,N> min, vector<T,N> max, vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> smoothstep(matrix<T,N,M> min, matrix<T,N,M> max, matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T smoothstep(T min, T max, T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> smoothstep(vector<T,N> min, vector<T,N> max, vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> smoothstep(matrix<T,N,M> min, matrix<T,N,M> max, matrix<T,N,M> x);
 
 // Square root
-__generic<T : __BuiltinFloatingPointType> __intrinsic T sqrt(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> sqrt(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> sqrt(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T sqrt(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> sqrt(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> sqrt(matrix<T,N,M> x);
 
 // Step function
-__generic<T : __BuiltinFloatingPointType> __intrinsic T step(T y, T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> step(vector<T,N> y, vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> step(matrix<T,N,M> y, matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T step(T y, T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> step(vector<T,N> y, vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> step(matrix<T,N,M> y, matrix<T,N,M> x);
 
 // Tangent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T tan(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> tan(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> tan(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T tan(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> tan(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> tan(matrix<T,N,M> x);
 
 // Hyperbolic tangent
-__generic<T : __BuiltinFloatingPointType> __intrinsic T tanh(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> tanh(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> tanh(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T tanh(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> tanh(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> tanh(matrix<T,N,M> x);
 
 // Legacy texture-fetch operations
 
 /*
-__intrinsic float4 tex1D(sampler1D s, float t);
-__intrinsic float4 tex1D(sampler1D s, float t, float ddx, float ddy);
-__intrinsic float4 tex1Dbias(sampler1D s, float4 t);
-__intrinsic float4 tex1Dgrad(sampler1D s, float t, float ddx, float ddy);
-__intrinsic float4 tex1Dlod(sampler1D s, float4 t);
-__intrinsic float4 tex1Dproj(sampler1D s, float4 t);
-
-__intrinsic float4 tex2D(sampler2D s, float2 t);
-__intrinsic float4 tex2D(sampler2D s, float2 t, float2 ddx, float2 ddy);
-__intrinsic float4 tex2Dbias(sampler2D s, float4 t);
-__intrinsic float4 tex2Dgrad(sampler2D s, float2 t, float2 ddx, float2 ddy);
-__intrinsic float4 tex2Dlod(sampler2D s, float4 t);
-__intrinsic float4 tex2Dproj(sampler2D s, float4 t);
-
-__intrinsic float4 tex3D(sampler3D s, float3 t);
-__intrinsic float4 tex3D(sampler3D s, float3 t, float3 ddx, float3 ddy);
-__intrinsic float4 tex3Dbias(sampler3D s, float4 t);
-__intrinsic float4 tex3Dgrad(sampler3D s, float3 t, float3 ddx, float3 ddy);
-__intrinsic float4 tex3Dlod(sampler3D s, float4 t);
-__intrinsic float4 tex3Dproj(sampler3D s, float4 t);
-
-__intrinsic float4 texCUBE(samplerCUBE s, float3 t);
-__intrinsic float4 texCUBE(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
-__intrinsic float4 texCUBEbias(samplerCUBE s, float4 t);
-__intrinsic float4 texCUBEgrad(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
-__intrinsic float4 texCUBElod(samplerCUBE s, float4 t);
-__intrinsic float4 texCUBEproj(samplerCUBE s, float4 t);
+__intrinsic_op float4 tex1D(sampler1D s, float t);
+__intrinsic_op float4 tex1D(sampler1D s, float t, float ddx, float ddy);
+__intrinsic_op float4 tex1Dbias(sampler1D s, float4 t);
+__intrinsic_op float4 tex1Dgrad(sampler1D s, float t, float ddx, float ddy);
+__intrinsic_op float4 tex1Dlod(sampler1D s, float4 t);
+__intrinsic_op float4 tex1Dproj(sampler1D s, float4 t);
+
+__intrinsic_op float4 tex2D(sampler2D s, float2 t);
+__intrinsic_op float4 tex2D(sampler2D s, float2 t, float2 ddx, float2 ddy);
+__intrinsic_op float4 tex2Dbias(sampler2D s, float4 t);
+__intrinsic_op float4 tex2Dgrad(sampler2D s, float2 t, float2 ddx, float2 ddy);
+__intrinsic_op float4 tex2Dlod(sampler2D s, float4 t);
+__intrinsic_op float4 tex2Dproj(sampler2D s, float4 t);
+
+__intrinsic_op float4 tex3D(sampler3D s, float3 t);
+__intrinsic_op float4 tex3D(sampler3D s, float3 t, float3 ddx, float3 ddy);
+__intrinsic_op float4 tex3Dbias(sampler3D s, float4 t);
+__intrinsic_op float4 tex3Dgrad(sampler3D s, float3 t, float3 ddx, float3 ddy);
+__intrinsic_op float4 tex3Dlod(sampler3D s, float4 t);
+__intrinsic_op float4 tex3Dproj(sampler3D s, float4 t);
+
+__intrinsic_op float4 texCUBE(samplerCUBE s, float3 t);
+__intrinsic_op float4 texCUBE(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
+__intrinsic_op float4 texCUBEbias(samplerCUBE s, float4 t);
+__intrinsic_op float4 texCUBEgrad(samplerCUBE s, float3 t, float3 ddx, float3 ddy);
+__intrinsic_op float4 texCUBElod(samplerCUBE s, float4 t);
+__intrinsic_op float4 texCUBEproj(samplerCUBE s, float4 t);
 */
 
 // Matrix transpose
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,M,N> transpose(matrix<T,N,M> x);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,M,N> transpose(matrix<T,N,M> x);
 
 // Truncate to integer
-__generic<T : __BuiltinFloatingPointType> __intrinsic T trunc(T x);
-__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic vector<T,N> trunc(vector<T,N> x);
-__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic matrix<T,N,M> trunc(matrix<T,N,M> x);
+__generic<T : __BuiltinFloatingPointType> __intrinsic_op T trunc(T x);
+__generic<T : __BuiltinFloatingPointType, let N : int> __intrinsic_op vector<T,N> trunc(vector<T,N> x);
+__generic<T : __BuiltinFloatingPointType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> trunc(matrix<T,N,M> x);
 
 
 )=", R"=(
 
 // Shader model 6.0 stuff
 
-__intrinsic uint GlobalOrderedCountIncrement(uint countToAppendForThisLane);
+__intrinsic_op uint GlobalOrderedCountIncrement(uint countToAppendForThisLane);
 
-__generic<T : __BuiltinType> __intrinsic T QuadReadLaneAt(T sourceValue, int quadLaneID);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> QuadReadLaneAt(vector<T,N> sourceValue, int quadLaneID);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> QuadReadLaneAt(matrix<T,N,M> sourceValue, int quadLaneID);
+__generic<T : __BuiltinType> __intrinsic_op T QuadReadLaneAt(T sourceValue, int quadLaneID);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> QuadReadLaneAt(vector<T,N> sourceValue, int quadLaneID);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> QuadReadLaneAt(matrix<T,N,M> sourceValue, int quadLaneID);
 
-__generic<T : __BuiltinType> __intrinsic T QuadSwapX(T localValue);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> QuadSwapX(vector<T,N> localValue);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> QuadSwapX(matrix<T,N,M> localValue);
+__generic<T : __BuiltinType> __intrinsic_op T QuadSwapX(T localValue);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> QuadSwapX(vector<T,N> localValue);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> QuadSwapX(matrix<T,N,M> localValue);
 
-__generic<T : __BuiltinType> __intrinsic T QuadSwapY(T localValue);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> QuadSwapY(vector<T,N> localValue);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> QuadSwapY(matrix<T,N,M> localValue);
+__generic<T : __BuiltinType> __intrinsic_op T QuadSwapY(T localValue);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> QuadSwapY(vector<T,N> localValue);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> QuadSwapY(matrix<T,N,M> localValue);
 
-__generic<T : __BuiltinIntegerType> __intrinsic T WaveAllBitAnd(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> __intrinsic vector<T,N> WaveAllBitAnd(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllBitAnd(matrix<T,N,M> expr);
+__generic<T : __BuiltinIntegerType> __intrinsic_op T WaveAllBitAnd(T expr);
+__generic<T : __BuiltinIntegerType, let N : int> __intrinsic_op vector<T,N> WaveAllBitAnd(vector<T,N> expr);
+__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllBitAnd(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinIntegerType> __intrinsic T WaveAllBitOr(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> __intrinsic vector<T,N> WaveAllBitOr(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllBitOr(matrix<T,N,M> expr);
+__generic<T : __BuiltinIntegerType> __intrinsic_op T WaveAllBitOr(T expr);
+__generic<T : __BuiltinIntegerType, let N : int> __intrinsic_op vector<T,N> WaveAllBitOr(vector<T,N> expr);
+__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllBitOr(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinIntegerType> __intrinsic T WaveAllBitXor(T expr);
-__generic<T : __BuiltinIntegerType, let N : int> __intrinsic vector<T,N> WaveAllBitXor(vector<T,N> expr);
-__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllBitXor(matrix<T,N,M> expr);
+__generic<T : __BuiltinIntegerType> __intrinsic_op T WaveAllBitXor(T expr);
+__generic<T : __BuiltinIntegerType, let N : int> __intrinsic_op vector<T,N> WaveAllBitXor(vector<T,N> expr);
+__generic<T : __BuiltinIntegerType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllBitXor(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WaveAllMax(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WaveAllMax(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllMax(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WaveAllMax(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WaveAllMax(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllMax(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WaveAllMin(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WaveAllMin(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllMin(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WaveAllMin(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WaveAllMin(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllMin(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WaveAllProduct(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WaveAllProduct(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllProduct(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WaveAllProduct(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WaveAllProduct(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllProduct(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WaveAllSum(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WaveAllSum(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveAllSum(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WaveAllSum(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WaveAllSum(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveAllSum(matrix<T,N,M> expr);
 
-__intrinsic bool WaveAllEqual(bool expr);
-__intrinsic bool WaveAllTrue(bool expr);
-__intrinsic bool WaveAnyTrue(bool expr);
+__intrinsic_op bool WaveAllEqual(bool expr);
+__intrinsic_op bool WaveAllTrue(bool expr);
+__intrinsic_op bool WaveAnyTrue(bool expr);
 
 uint64_t WaveBallot(bool expr);
 
@@ -1015,21 +1015,21 @@ bool WaveIsHelperLane();
 
 bool WaveOnce();
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WavePrefixProduct(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WavePrefixProduct(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WavePrefixProduct(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WavePrefixProduct(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WavePrefixProduct(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WavePrefixProduct(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinArithmeticType> __intrinsic T WavePrefixSum(T expr);
-__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic vector<T,N> WavePrefixSum(vector<T,N> expr);
-__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic matrix<T,N,M> WavePrefixSum(matrix<T,N,M> expr);
+__generic<T : __BuiltinArithmeticType> __intrinsic_op T WavePrefixSum(T expr);
+__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op vector<T,N> WavePrefixSum(vector<T,N> expr);
+__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WavePrefixSum(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinType> __intrinsic T WaveReadFirstLane(T expr);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> WaveReadFirstLane(vector<T,N> expr);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveReadFirstLane(matrix<T,N,M> expr);
+__generic<T : __BuiltinType> __intrinsic_op T WaveReadFirstLane(T expr);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> WaveReadFirstLane(vector<T,N> expr);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveReadFirstLane(matrix<T,N,M> expr);
 
-__generic<T : __BuiltinType> __intrinsic T WaveReadLaneAt(T expr, int laneIndex);
-__generic<T : __BuiltinType, let N : int> __intrinsic vector<T,N> WaveReadLaneAt(vector<T,N> expr, int laneIndex);
-__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic matrix<T,N,M> WaveReadLaneAt(matrix<T,N,M> expr, int laneIndex);
+__generic<T : __BuiltinType> __intrinsic_op T WaveReadLaneAt(T expr, int laneIndex);
+__generic<T : __BuiltinType, let N : int> __intrinsic_op vector<T,N> WaveReadLaneAt(vector<T,N> expr, int laneIndex);
+__generic<T : __BuiltinType, let N : int, let M : int> __intrinsic_op matrix<T,N,M> WaveReadLaneAt(matrix<T,N,M> expr, int laneIndex);
 
 
 )=", R"=(
@@ -1226,54 +1226,48 @@ namespace Slang
         }
     }
 
-    struct OpInfo { IntrinsicOp opCode; char const* opName; unsigned flags; };
+    struct OpInfo { int32_t opCode; char const* opName; unsigned flags; };
 
     static const OpInfo unaryOps[] = {
-        { IntrinsicOp::Pos,     "+",    ARITHMETIC_MASK },
-        { IntrinsicOp::Neg,     "-",    ARITHMETIC_MASK },
-        { IntrinsicOp::Not,     "!",    ANY_MASK        },
-        { IntrinsicOp::BitNot,  "~",    INT_MASK        },
-        { IntrinsicOp::PreInc,  "++",   ARITHMETIC_MASK | ASSIGNMENT },
-        { IntrinsicOp::PreDec,  "--",   ARITHMETIC_MASK | ASSIGNMENT },
-        { IntrinsicOp::PostInc, "++",   ARITHMETIC_MASK | ASSIGNMENT | POSTFIX },
-        { IntrinsicOp::PostDec, "--",   ARITHMETIC_MASK | ASSIGNMENT | POSTFIX },
+        { kIRPseudoOp_Pos,     "+",    ARITHMETIC_MASK },
+        { kIROp_Neg,     "-",    ARITHMETIC_MASK },
+        { kIROp_Not,     "!",    ANY_MASK        },
+        { kIRPseudoOp_BitNot,    "~",    INT_MASK        },
+        { kIRPseudoOp_PreInc,  "++",   ARITHMETIC_MASK | ASSIGNMENT },
+        { kIRPseudoOp_PreDec,  "--",   ARITHMETIC_MASK | ASSIGNMENT },
+        { kIRPseudoOp_PostInc, "++",   ARITHMETIC_MASK | ASSIGNMENT | POSTFIX },
+        { kIRPseudoOp_PostDec, "--",   ARITHMETIC_MASK | ASSIGNMENT | POSTFIX },
     };
 
     static const OpInfo binaryOps[] = {
-        { IntrinsicOp::Add,     "+",    ARITHMETIC_MASK },
-        { IntrinsicOp::Sub,     "-",    ARITHMETIC_MASK },
-        { IntrinsicOp::Mul,     "*",    ARITHMETIC_MASK },
-        { IntrinsicOp::Div,     "/",    ARITHMETIC_MASK },
-        { IntrinsicOp::Mod,     "%",    INT_MASK },
-
-        { IntrinsicOp::And,     "&&",   LOGICAL_MASK },
-        { IntrinsicOp::Or,      "||",   LOGICAL_MASK },
-
-        { IntrinsicOp::BitAnd,  "&",    LOGICAL_MASK },
-        { IntrinsicOp::BitOr,   "|",    LOGICAL_MASK },
-        { IntrinsicOp::BitXor,  "^",    LOGICAL_MASK },
-
-        { IntrinsicOp::Lsh,     "<<",   INT_MASK },
-        { IntrinsicOp::Rsh,     ">>",   INT_MASK },
-
-        { IntrinsicOp::Eql,     "==",   ANY_MASK | COMPARISON },
-        { IntrinsicOp::Neq,     "!=",   ANY_MASK | COMPARISON },
-
-        { IntrinsicOp::Greater, ">",    ARITHMETIC_MASK | COMPARISON },
-        { IntrinsicOp::Less,    "<",    ARITHMETIC_MASK | COMPARISON },
-        { IntrinsicOp::Geq,     ">=",   ARITHMETIC_MASK | COMPARISON },
-        { IntrinsicOp::Leq,     "<=",   ARITHMETIC_MASK | COMPARISON },
-
-        { IntrinsicOp::AddAssign,     "+=",    ASSIGNMENT | ARITHMETIC_MASK },
-        { IntrinsicOp::SubAssign,     "-=",    ASSIGNMENT | ARITHMETIC_MASK },
-        { IntrinsicOp::MulAssign,     "*=",    ASSIGNMENT | ARITHMETIC_MASK },
-        { IntrinsicOp::DivAssign,     "/=",    ASSIGNMENT | ARITHMETIC_MASK },
-        { IntrinsicOp::ModAssign,     "%=",    ASSIGNMENT | ARITHMETIC_MASK },
-        { IntrinsicOp::AndAssign,     "&=",    ASSIGNMENT | LOGICAL_MASK },
-        { IntrinsicOp::OrAssign,      "|=",    ASSIGNMENT | LOGICAL_MASK },
-        { IntrinsicOp::XorAssign,     "^=",    ASSIGNMENT | LOGICAL_MASK },
-        { IntrinsicOp::LshAssign,     "<<=",   ASSIGNMENT | INT_MASK },
-        { IntrinsicOp::RshAssign,     ">>=",   ASSIGNMENT | INT_MASK },
+        { kIROp_Add,     "+",    ARITHMETIC_MASK },
+        { kIROp_Sub,     "-",    ARITHMETIC_MASK },
+        { kIROp_Mul,     "*",    ARITHMETIC_MASK },
+        { kIROp_Div,     "/",    ARITHMETIC_MASK },
+        { kIROp_Mod,     "%",    INT_MASK },
+        { kIROp_And,     "&&",   LOGICAL_MASK },
+        { kIROp_Or,      "||",   LOGICAL_MASK },
+        { kIROp_BitAnd,  "&",    LOGICAL_MASK },
+        { kIROp_BitOr,   "|",    LOGICAL_MASK },
+        { kIROp_BitXor,  "^",    LOGICAL_MASK },
+        { kIROp_Lsh,     "<<",   INT_MASK },
+        { kIROp_Rsh,     ">>",   INT_MASK },
+        { kIROp_Eql,     "==",   ANY_MASK | COMPARISON },
+        { kIROp_Neq,     "!=",   ANY_MASK | COMPARISON },
+        { kIROp_Greater, ">",    ARITHMETIC_MASK | COMPARISON },
+        { kIROp_Less,    "<",    ARITHMETIC_MASK | COMPARISON },
+        { kIROp_Geq,     ">=",   ARITHMETIC_MASK | COMPARISON },
+        { kIROp_Leq,     "<=",   ARITHMETIC_MASK | COMPARISON },
+        { kIRPseudoOp_AddAssign,     "+=",    ASSIGNMENT | ARITHMETIC_MASK },
+        { kIRPseudoOp_SubAssign,     "-=",    ASSIGNMENT | ARITHMETIC_MASK },
+        { kIRPseudoOp_MulAssign,     "*=",    ASSIGNMENT | ARITHMETIC_MASK },
+        { kIRPseudoOp_DivAssign,     "/=",    ASSIGNMENT | ARITHMETIC_MASK },
+        { kIRPseudoOp_ModAssign,     "%=",    ASSIGNMENT | ARITHMETIC_MASK },
+        { kIRPseudoOp_AndAssign,     "&=",    ASSIGNMENT | LOGICAL_MASK },
+        { kIRPseudoOp_OrAssign,      "|=",    ASSIGNMENT | LOGICAL_MASK },
+        { kIRPseudoOp_XorAssign,     "^=",    ASSIGNMENT | LOGICAL_MASK },
+        { kIRPseudoOp_LshAssign,     "<<=",   ASSIGNMENT | INT_MASK },
+        { kIRPseudoOp_RshAssign,     ">>=",   ASSIGNMENT | INT_MASK },
     };
 
     String Session::getCoreLibraryCode()
@@ -1623,7 +1617,7 @@ namespace Slang
                     {
                         {
                             sb << "__glsl_version(450)\n";
-                            sb << "__intrinsic(glsl, \"(";
+                            sb << "__target_intrinsic(glsl, \"(";
 
                             int aa = 0;
                             String lodStr = "0";
@@ -1679,7 +1673,7 @@ namespace Slang
 
 
                             sb << ")\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__intrinsic_op\n";
 
                         }
 
@@ -1748,13 +1742,13 @@ namespace Slang
 
                         if (isMultisample)
                         {
-                            sb << "__intrinsic(glsl, \"texelFetch($P, $0, $1)\")\n";
+                            sb << "__target_intrinsic(glsl, \"texelFetch($P, $0, $1)\")\n";
                         }
                         else
                         {
-                            sb << "__intrinsic(glsl, \"texelFetch($P, ($0)." << kGLSLLoadCoordsSwizzle[loadCoordCount] << ", ($0)." << kGLSLLoadLODSwizzle[loadCoordCount] << ")\")\n";
+                            sb << "__target_intrinsic(glsl, \"texelFetch($P, ($0)." << kGLSLLoadCoordsSwizzle[loadCoordCount] << ", ($0)." << kGLSLLoadLODSwizzle[loadCoordCount] << ")\")\n";
                         }
-                        sb << "__intrinsic\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T Load(";
                         sb << "int" << loadCoordCount << " location";
                         if(isMultisample)
@@ -1765,13 +1759,13 @@ namespace Slang
 
                         if (isMultisample)
                         {
-                            sb << "__intrinsic(glsl, \"texelFetchOffset($P, $0, $1, $2)\")\n";
+                            sb << "__target_intrinsic(glsl, \"texelFetchOffset($P, $0, $1, $2)\")\n";
                         }
                         else
                         {
-                            sb << "__intrinsic(glsl, \"texelFetch($P, ($0)." << kGLSLLoadCoordsSwizzle[loadCoordCount] << ", ($0)." << kGLSLLoadLODSwizzle[loadCoordCount] << ", $1)\")\n";
+                            sb << "__target_intrinsic(glsl, \"texelFetch($P, ($0)." << kGLSLLoadCoordsSwizzle[loadCoordCount] << ", ($0)." << kGLSLLoadLODSwizzle[loadCoordCount] << ", $1)\")\n";
                         }
-                        sb << "__intrinsic\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T Load(";
                         sb << "int" << loadCoordCount << " location";
                         if(isMultisample)
@@ -1796,26 +1790,26 @@ namespace Slang
                     if(baseShape != TextureType::ShapeCube)
                     {
                         // subscript operator
-                        sb << "__intrinsic __subscript(uint" << kBaseTextureTypes[tt].coordCount + isArray << " location) -> T;\n";
+                        sb << "__intrinsic_op __subscript(uint" << kBaseTextureTypes[tt].coordCount + isArray << " location) -> T;\n";
                     }
 
                     if( !isMultisample )
                     {
                         // `Sample()`
 
-                        sb << "__intrinsic(glsl, \"texture($p, $1)\")\n";
+                        sb << "__target_intrinsic(glsl, \"texture($p, $1)\")\n";
 
                         // TODO: only enable if IR is being used?
-                        sb << "__intrinsic_op(sample_t_s_u)\n";
+                        sb << "__intrinsic_op(sample)\n";
 
-                        sb << "__intrinsic\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T Sample(SamplerState s, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location);\n";
 
                         if( baseShape != TextureType::ShapeCube )
                         {
-                            sb << "__intrinsic(glsl, \"textureOffset($p, $1, $2)\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureOffset($p, $1, $2)\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "T Sample(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                             sb << "int" << kBaseTextureTypes[tt].coordCount << " offset);\n";
@@ -1839,15 +1833,15 @@ namespace Slang
 
 
                         // `SampleBias()`
-                        sb << "__intrinsic(glsl, \"texture($p, $1, $2)\")\n";
-                        sb << "__intrinsic\n";
+                        sb << "__target_intrinsic(glsl, \"texture($p, $1, $2)\")\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T SampleBias(SamplerState s, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, float bias);\n";
 
                         if( baseShape != TextureType::ShapeCube )
                         {
-                            sb << "__intrinsic(glsl, \"textureOffset($p, $1, $2, $3)\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureOffset($p, $1, $2, $3)\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "T SampleBias(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, float bias, ";
                             sb << "int" << kBaseTextureTypes[tt].coordCount << " offset);\n";
@@ -1868,7 +1862,7 @@ namespace Slang
                             if (extCoordCount < 3)
                                 extCoordCount = 3;
 
-                            sb << "__intrinsic(glsl, \"textureLod($p, ";
+                            sb << "__target_intrinsic(glsl, \"textureLod($p, ";
 
                             sb << "vec" << extCoordCount << "($1,";
                             for (int ii = arrCoordCount; ii < extCoordCount - 1; ++ii)
@@ -1886,7 +1880,7 @@ namespace Slang
                             if (extCoordCount < 3)
                                 extCoordCount = 3;
 
-                            sb << "__intrinsic(glsl, \"textureGrad($p, ";
+                            sb << "__target_intrinsic(glsl, \"textureGrad($p, ";
 
                             sb << "vec" << extCoordCount << "($1,";
                             for (int ii = arrCoordCount; ii < extCoordCount - 1; ++ii)
@@ -1900,7 +1894,7 @@ namespace Slang
                             sb << ", vec" << baseCoordCount << "(0.0)";
                             sb << ")\")\n";
                         }
-                        sb << "__intrinsic\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T SampleCmpLevelZero(SamplerComparisonState s, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                         sb << "float compareValue";
@@ -1927,8 +1921,8 @@ namespace Slang
                         }
 
 
-                        sb << "__intrinsic(glsl, \"textureGrad($p, $1, $2, $3)\")\n";
-                        sb << "__intrinsic\n";
+                        sb << "__target_intrinsic(glsl, \"textureGrad($p, $1, $2, $3)\")\n";
+                        sb << "__intrinsic_op(sampleGrad)\n";
                         sb << "T SampleGrad(SamplerState s, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount << " gradX, ";
@@ -1937,8 +1931,8 @@ namespace Slang
 
                         if( baseShape != TextureType::ShapeCube )
                         {
-                            sb << "__intrinsic(glsl, \"textureGradOffset($p, $1, $2, $3, $4)\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureGradOffset($p, $1, $2, $3, $4)\")\n";
+                            sb << "__intrinsic_op(sampleGrad)\n";
                             sb << "T SampleGrad(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount << " gradX, ";
@@ -1948,16 +1942,16 @@ namespace Slang
 
                         // `SampleLevel`
 
-                        sb << "__intrinsic(glsl, \"textureLod($p, $1, $2)\")\n";
-                        sb << "__intrinsic\n";
+                        sb << "__target_intrinsic(glsl, \"textureLod($p, $1, $2)\")\n";
+                        sb << "__intrinsic_op\n";
                         sb << "T SampleLevel(SamplerState s, ";
                         sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                         sb << "float level);\n";
 
                         if( baseShape != TextureType::ShapeCube )
                         {
-                            sb << "__intrinsic(glsl, \"textureLodOffset($p, $1, $2, $3)\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureLodOffset($p, $1, $2, $3)\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "T SampleLevel(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount + isArray << " location, ";
                             sb << "float level, ";
@@ -2024,14 +2018,14 @@ namespace Slang
 
                             EMIT_LINE_DIRECTIVE();
                             
-                            sb << "__intrinsic(glsl, \"textureGather($p, $1, " << componentIndex << ")\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureGather($p, $1, " << componentIndex << ")\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "vector<T, 4> Gather" << componentName << "(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount << " location);\n";
 
                             EMIT_LINE_DIRECTIVE();
-                            sb << "__intrinsic(glsl, \"textureGatherOffset($p, $1, $2, " << componentIndex << ")\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureGatherOffset($p, $1, $2, " << componentIndex << ")\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "vector<T, 4> Gather" << componentName << "(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount << " location, ";
                             sb << "int" << kBaseTextureTypes[tt].coordCount << " offset);\n";
@@ -2043,8 +2037,8 @@ namespace Slang
                             sb << "out uint status);\n";
 
                             EMIT_LINE_DIRECTIVE();
-                            sb << "__intrinsic(glsl, \"textureGatherOffsets($p, $1, int" << kBaseTextureTypes[tt].coordCount << "[]($2, $3, $4, $5), " << componentIndex << ")\")\n";
-                            sb << "__intrinsic\n";
+                            sb << "__target_intrinsic(glsl, \"textureGatherOffsets($p, $1, int" << kBaseTextureTypes[tt].coordCount << "[]($2, $3, $4, $5), " << componentIndex << ")\")\n";
+                            sb << "__intrinsic_op\n";
                             sb << "vector<T, 4> Gather" << componentName << "(SamplerState s, ";
                             sb << "float" << kBaseTextureTypes[tt].coordCount << " location, ";
                             sb << "int" << kBaseTextureTypes[tt].coordCount << " offset1, ";
@@ -2126,8 +2120,8 @@ namespace Slang
                 // skip matrix-matrix multiply operations here, so that GLSL doesn't see them
                 switch (op.opCode)
                 {
-                case IntrinsicOp::Mul:
-                case IntrinsicOp::MulAssign:
+                case kIROp_Mul:
+                case kIRPseudoOp_MulAssign:
                     break;
 
                 default:
@@ -2188,8 +2182,8 @@ namespace Slang
             default:
                 continue;
 
-            case IntrinsicOp::Mul:
-            case IntrinsicOp::MulAssign:
+            case kIROp_Mul:
+            case kIRPseudoOp_MulAssign:
                 break;
             }
 
@@ -2233,15 +2227,15 @@ namespace Slang
             sb << kBaseBufferAccessLevels[aa].name;
             sb << "Buffer {\n";
 
-            sb << "__intrinsic void GetDimensions(out uint dim);\n";
+            sb << "__intrinsic_op void GetDimensions(out uint dim);\n";
 
-            sb << "__intrinsic(glsl, \"texelFetch($P, $0)$z\")\n";
-            sb << "__intrinsic T Load(int location);\n";
+            sb << "__target_intrinsic(glsl, \"texelFetch($P, $0)$z\")\n";
+            sb << "__intrinsic_op T Load(int location);\n";
 
-            sb << "__intrinsic T Load(int location, out uint status);\n";
+            sb << "__intrinsic_op T Load(int location, out uint status);\n";
 
-            sb << "__intrinsic(glsl, \"texelFetch($P, int($0))$z\")\n";
-            sb << "__intrinsic __subscript(uint index) -> T";
+            sb << "__target_intrinsic(glsl, \"texelFetch($P, int($0))$z\")\n";
+            sb << "__intrinsic_op __subscript(uint index) -> T";
 
             if (kBaseBufferAccessLevels[aa].access != SLANG_RESOURCE_ACCESS_READ)
             {
@@ -2310,24 +2304,24 @@ namespace Slang
         // Multiplication operations for vectors + matrices
 
         // scalar-vector and vector-scalar
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(Mul) vector<T,N> operator*(vector<T,N> x, T y);\n";
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(Mul) vector<T,N> operator*(T x, vector<T,N> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(mul) vector<T,N> operator*(vector<T,N> x, T y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(mul) vector<T,N> operator*(T x, vector<T,N> y);\n";
 
         // scalar-matrix and matrix-scalar
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(Mul) matrix<T,N,M> operator*(matrix<T,N,M> x, T y);\n";
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(Mul) matrix<T,N,M> operator*(T x, matrix<T,N,M> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(mul) matrix<T,N,M> operator*(matrix<T,N,M> x, T y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M :int> __intrinsic_op(mul) matrix<T,N,M> operator*(T x, matrix<T,N,M> y);\n";
 
         // vector-vector (dot product)
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(Mul) T operator*(vector<T,N> x, vector<T,N> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int> __intrinsic_op(dot) T operator*(vector<T,N> x, vector<T,N> y);\n";
 
         // vector-matrix
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(Mul) vector<T,M> operator*(vector<T,N> x, matrix<T,N,M> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulVectorMatrix) vector<T,M> operator*(vector<T,N> x, matrix<T,N,M> y);\n";
 
         // matrix-vector
-        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(Mul) vector<T,N> operator*(matrix<T,N,M> x, vector<T,M> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let N : int, let M : int> __intrinsic_op(mulMatrixVector) vector<T,N> operator*(matrix<T,N,M> x, vector<T,M> y);\n";
 
         // matrix-matrix
-        sb << "__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(Mul) matrix<T,R,C> operator*(matrix<T,R,N> x, matrix<T,N,C> y);\n";
+        sb << "__generic<T : __BuiltinArithmeticType, let R : int, let N : int, let C : int> __intrinsic_op(mulMatrixMatrix) matrix<T,R,C> operator*(matrix<T,R,N> x, matrix<T,N,C> y);\n";
 
 
 
diff --git a/source/slang/slang.vcxproj b/source/slang/slang.vcxproj
index c8a564f2c..bc41ddb71 100644
--- a/source/slang/slang.vcxproj
+++ b/source/slang/slang.vcxproj
@@ -171,7 +171,6 @@
     <ClInclude Include="diagnostics.h" />
     <ClInclude Include="emit.h" />
     <ClInclude Include="expr-defs.h" />
-    <ClInclude Include="intrinsic-defs.h" />
     <ClInclude Include="ir-inst-defs.h" />
     <ClInclude Include="ir.h" />
     <ClInclude Include="lexer.h" />
diff --git a/source/slang/slang.vcxproj.filters b/source/slang/slang.vcxproj.filters
index d8fdf1fc1..4bd7ff9a0 100644
--- a/source/slang/slang.vcxproj.filters
+++ b/source/slang/slang.vcxproj.filters
@@ -8,7 +8,6 @@
     <ClInclude Include="diagnostic-defs.h" />
     <ClInclude Include="diagnostics.h" />
     <ClInclude Include="emit.h" />
-    <ClInclude Include="intrinsic-defs.h" />
     <ClInclude Include="lexer.h" />
     <ClInclude Include="lookup.h" />
     <ClInclude Include="parameter-binding.h" />
diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp
index 8bd42a7e4..d02f880fd 100644
--- a/source/slang/syntax.cpp
+++ b/source/slang/syntax.cpp
@@ -1092,17 +1092,6 @@ void Type::accept(IValVisitor* visitor, void* extra)
         }
     }
 
-    IntrinsicOp findIntrinsicOp(char const* name)
-    {
-        // TODO: need to make this faster by using a dictionary...
-
-        if (0) {}
-#define INTRINSIC(NAME) else if(strcmp(name, #NAME) == 0) return IntrinsicOp::NAME;
-#include "intrinsic-defs.h"
-
-        return IntrinsicOp::Unknown;
-    }
-
     //
 
     // HLSLPatchType
diff --git a/source/slang/syntax.h b/source/slang/syntax.h
index 3a7d25f6c..2fcfe8d39 100644
--- a/source/slang/syntax.h
+++ b/source/slang/syntax.h
@@ -2,10 +2,11 @@
 #define RASTER_RENDERER_SYNTAX_H
 
 #include "../core/basic.h"
-#include "Lexer.h"
-#include "Profile.h"
+#include "ir.h"
+#include "lexer.h"
+#include "profile.h"
 
-#include "../../Slang.h"
+#include "../../slang.h"
 
 #include <assert.h>
 
@@ -80,15 +81,6 @@ namespace Slang
 #include "syntax-defs.h"
 #include "object-meta-end.h"
 
-    enum class IntrinsicOp
-    {
-        Unknown = 0,
-#define INTRINSIC(NAME) NAME,
-#include "intrinsic-defs.h"
-    };
-
-    IntrinsicOp findIntrinsicOp(char const* name);
-
     // Helper type for pairing up a name and the location where it appeared
     struct NameLoc
     {
@@ -243,21 +235,6 @@ namespace Slang
         FilteredModifierList<Modifier>::Iterator end() { return FilteredModifierList<Modifier>::Iterator(nullptr); }
     };
 
-
-    enum class BaseType
-    {
-        // Note(tfoley): These are ordered in terms of promotion rank, so be vareful when messing with this
-
-        Void = 0,
-        Bool,
-        Int,
-        UInt,
-        UInt64,
-        Half,
-        Float,
-        Double,
-    };
-
     class NamedExpressionType;
     class GenericDecl;
     class ContainerDecl;