Implement GL_EXT_function_control_attributes

Karpov-Ruslan · arcady-lunarg · commit 598bd843da87 · 2026-07-23T17:00:21.000-04:00
diff --git a/SPIRV/GlslangToSpv.cpp b/SPIRV/GlslangToSpv.cpp
@@ -233,6 +233,7 @@ class TGlslangToSpvTraverser : public glslang::TIntermTraverser {
     spv::SelectionControlMask TranslateSelectionControl(const glslang::TIntermSelection&) const;
     spv::SelectionControlMask TranslateSwitchControl(const glslang::TIntermSwitch&) const;
     spv::LoopControlMask TranslateLoopControl(const glslang::TIntermLoop&, std::vector<unsigned int>& operands) const;
+    spv::FunctionControlMask TranslateFunctionControl(unsigned int) const;
     spv::StorageClass TranslateStorageClass(const glslang::TType&);
     void TranslateLiterals(const glslang::TVector<const glslang::TIntermConstantUnion*>&, std::vector<unsigned>&) const;
     void addIndirectionIndexCapabilities(const glslang::TType& baseType, const glslang::TType& indexType);
@@ -1428,6 +1429,18 @@ spv::SelectionControlMask TGlslangToSpvTraverser::TranslateSwitchControl(const g
     return spv::SelectionControlMask::MaskNone;
 }
 
+spv::FunctionControlMask TGlslangToSpvTraverser::TranslateFunctionControl(unsigned int functionControl) const
+{
+    spv::FunctionControlMask control = spv::FunctionControlMask::MaskNone;
+
+    if (functionControl & glslang::EfcInline)
+        control = control | spv::FunctionControlMask::Inline;
+    if (functionControl & glslang::EfcDontInline)
+        control = control | spv::FunctionControlMask::DontInline;
+
+    return control;
+}
+
 // return a non-0 dependency if the dependency argument must be set
 spv::LoopControlMask TGlslangToSpvTraverser::TranslateLoopControl(const glslang::TIntermLoop& loopNode,
     std::vector<unsigned int>& operands) const
@@ -7493,6 +7506,7 @@ void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslF
         builder.setDebugSourceLocation(glslFunction->getLoc().line, glslFunction->getLoc().getFilename());
 
         if (isShaderEntryPoint(glslFunction)) {
+            shaderEntry->setFunctionControl(TranslateFunctionControl(glslFunction->getFunctionControl()));
             // For HLSL, the entry function is actually a compiler generated function to resolve the difference of
             // entry function signature between HLSL and SPIR-V. So we don't emit debug information for that.
             if (glslangIntermediate->getSource() != glslang::EShSourceHlsl) {
@@ -7551,6 +7565,7 @@ void TGlslangToSpvTraverser::makeFunctions(const glslang::TIntermSequence& glslF
             TranslatePrecisionDecoration(glslFunction->getType()), convertGlslangToSpvType(glslFunction->getType()),
             glslFunction->getName().c_str(), convertGlslangLinkageToSpv(glslFunction->getLinkType()), paramTypes,
             paramDecorations, &functionBlock);
+        function->setFunctionControl(TranslateFunctionControl(glslFunction->getFunctionControl()));
         builder.setupFunctionDebugInfo(function, glslFunction->getName().c_str(), paramTypes, paramNames);
         if (implicitThis)
             function->setImplicitThis();
diff --git a/SPIRV/spvIR.h b/SPIRV/spvIR.h
@@ -481,6 +481,10 @@ class Function {
     Id getReturnType() const { return functionInstruction.getTypeId(); }
     Id getFuncId() const { return functionInstruction.getResultId(); }
     Id getFuncTypeId() const { return functionInstruction.getIdOperand(1); }
+    void setFunctionControl(FunctionControlMask functionControl)
+    {
+        functionInstruction.setImmediateOperand(0, static_cast<unsigned>(functionControl));
+    }
     void setReturnPrecision(Decoration precision)
     {
         if (precision == Decoration::RelaxedPrecision)
diff --git a/Test/baseResults/spv.functionControlAttributes.error.frag.out b/Test/baseResults/spv.functionControlAttributes.error.frag.out
@@ -0,0 +1,7 @@
+spv.functionControlAttributes.error.frag
+ERROR: 0:7: 'sameDeclaration' : function attributes are incompatible 
+ERROR: 0:14: 'prototypeConflict' : function attributes are incompatible 
+ERROR: 2 compilation errors.  No code generated.
+
+
+SPIR-V is not generated for failed compile or link
diff --git a/Test/baseResults/spv.functionControlAttributes.frag.out b/Test/baseResults/spv.functionControlAttributes.frag.out
@@ -0,0 +1,95 @@
+spv.functionControlAttributes.frag
+// Module Version 10000
+// Generated by (magic number): 8000b
+// Id's are bound by 61
+
+                              Capability Shader
+               1:             ExtInstImport  "GLSL.std.450"
+                              MemoryModel Logical GLSL450
+                              EntryPoint Fragment 4  "main" 57
+                              ExecutionMode 4 OriginUpperLeft
+                              Source GLSL 450
+                              SourceExtension  "GL_EXT_function_control_attributes"
+                              Name 4  "main"
+                              Name 10  "inlineFn(i1;"
+                              Name 9  "i"
+                              Name 13  "noinlineFn(i1;"
+                              Name 12  "i"
+                              Name 16  "backFn(i1;"
+                              Name 15  "i"
+                              Name 19  "prototypeFn(i1;"
+                              Name 18  "i"
+                              Name 41  "value"
+                              Name 42  "param"
+                              Name 44  "param"
+                              Name 49  "param"
+                              Name 57  "color"
+                              Decorate 57(color) Location 0
+               2:             TypeVoid
+               3:             TypeFunction 2
+               6:             TypeInt 32 1
+               7:             TypePointer Function 6(int)
+               8:             TypeFunction 6(int) 7(ptr)
+              22:      6(int) Constant 1
+              27:      6(int) Constant 2
+              32:      6(int) Constant 3
+              37:      6(int) Constant 4
+              54:             TypeFloat 32
+              55:             TypeVector 54(float) 4
+              56:             TypePointer Output 55(fvec4)
+       57(color):     56(ptr) Variable Output
+         4(main):           2 Function None 3
+               5:             Label
+       41(value):      7(ptr) Variable Function
+       42(param):      7(ptr) Variable Function
+       44(param):      7(ptr) Variable Function
+       49(param):      7(ptr) Variable Function
+                              Store 42(param) 22
+              43:      6(int) FunctionCall 10(inlineFn(i1;) 42(param)
+                              Store 41(value) 43
+              45:      6(int) Load 41(value)
+                              Store 44(param) 45
+              46:      6(int) FunctionCall 13(noinlineFn(i1;) 44(param)
+              47:      6(int) Load 41(value)
+              48:      6(int) IAdd 47 46
+                              Store 41(value) 48
+              50:      6(int) Load 41(value)
+                              Store 49(param) 50
+              51:      6(int) FunctionCall 19(prototypeFn(i1;) 49(param)
+              52:      6(int) Load 41(value)
+              53:      6(int) IAdd 52 51
+                              Store 41(value) 53
+              58:      6(int) Load 41(value)
+              59:   54(float) ConvertSToF 58
+              60:   55(fvec4) CompositeConstruct 59 59 59 59
+                              Store 57(color) 60
+                              Return
+                              FunctionEnd
+10(inlineFn(i1;):      6(int) Function Inline  8
+            9(i):      7(ptr) FunctionParameter
+              11:             Label
+              21:      6(int) Load 9(i)
+              23:      6(int) IAdd 21 22
+                              ReturnValue 23
+                              FunctionEnd
+13(noinlineFn(i1;):      6(int) Function DontInline  8
+           12(i):      7(ptr) FunctionParameter
+              14:             Label
+              26:      6(int) Load 12(i)
+              28:      6(int) IAdd 26 27
+                              ReturnValue 28
+                              FunctionEnd
+  16(backFn(i1;):      6(int) Function Inline  8
+           15(i):      7(ptr) FunctionParameter
+              17:             Label
+              31:      6(int) Load 15(i)
+              33:      6(int) IAdd 31 32
+                              ReturnValue 33
+                              FunctionEnd
+19(prototypeFn(i1;):      6(int) Function Inline  8
+           18(i):      7(ptr) FunctionParameter
+              20:             Label
+              36:      6(int) Load 18(i)
+              38:      6(int) IAdd 36 37
+                              ReturnValue 38
+                              FunctionEnd
diff --git a/Test/spv.functionControlAttributes.error.frag b/Test/spv.functionControlAttributes.error.frag
@@ -0,0 +1,22 @@
+#version 450
+
+#extension GL_EXT_function_control_attributes : enable
+
+layout(location = 0) out vec4 color;
+
+[[inline, noinline]] int sameDeclaration(int i)
+{
+    return i;
+}
+
+[[inline]] int prototypeConflict(int i);
+
+[[noinline]] int prototypeConflict(int i)
+{
+    return i;
+}
+
+void main()
+{
+    color = vec4(0.0);
+}
diff --git a/Test/spv.functionControlAttributes.frag b/Test/spv.functionControlAttributes.frag
@@ -0,0 +1,35 @@
+#version 450
+
+#extension GL_EXT_function_control_attributes : enable
+
+layout(location = 0) out vec4 color;
+
+[[inline]] int inlineFn(int i)
+{
+    return i + 1;
+}
+
+[[noinline]] int noinlineFn(int i)
+{
+    return i + 2;
+}
+
+int backFn(int i) [[inline]]
+{
+    return i + 3;
+}
+
+[[inline]] int prototypeFn (int i);
+
+int prototypeFn(int i)
+{
+    return i + 4;
+}
+
+void main()
+{
+    int value = inlineFn(1);
+    value += noinlineFn(value);
+    value += prototypeFn(value);
+    color = vec4(float(value));
+}
diff --git a/glslang/Include/intermediate.h b/glslang/Include/intermediate.h
@@ -1104,6 +1104,12 @@ enum TLinkType {
     ELinkExport,
 };
 
+enum TFunctionControl {
+    EfcNone       = 0,
+    EfcInline     = 0x1,
+    EfcDontInline = 0x2,
+};
+
 class TIntermTraverser;
 class TIntermVariableDecl;
 class TIntermOperator;
@@ -1730,7 +1736,7 @@ typedef TVector<TStorageQualifier> TQualifierList;
 //
 class TIntermAggregate : public TIntermOperator {
 public:
-    TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(nullptr) { 
+    TIntermAggregate() : TIntermOperator(EOpNull), userDefined(false), pragmaTable(nullptr) {
         endLoc.init();
     }
     TIntermAggregate(TOperator o) : TIntermOperator(o), pragmaTable(nullptr) {
@@ -1764,6 +1770,8 @@ class TIntermAggregate : public TIntermOperator {
 
     void setLinkType(TLinkType l) { linkType = l; }
     TLinkType getLinkType() const { return linkType; }
+    void setFunctionControl(unsigned int fc) { functionControl = fc; }
+    unsigned int getFunctionControl() const { return functionControl; }
 protected:
     TIntermAggregate(const TIntermAggregate&); // disallow copy constructor
     TIntermAggregate& operator=(const TIntermAggregate&); // disallow assignment operator
@@ -1776,6 +1784,7 @@ class TIntermAggregate : public TIntermOperator {
     TPragmaTable* pragmaTable;
     TSpirvInstruction spirvInst;
     TLinkType linkType = ELinkNone;
+    unsigned int functionControl = EfcNone;
 
     // Marking the end source location of the aggregate.
     // This is currently only set for a compound statement or a function body, pointing to '}'.
diff --git a/glslang/MachineIndependent/ParseHelper.cpp b/glslang/MachineIndependent/ParseHelper.cpp
@@ -1259,6 +1259,13 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct
         }
         if (!parameterTypesDiffer && prevDec->getType() != function.getType())
             error(loc, "overloaded functions must have the same return type", function.getName().c_str(), "");
+
+        function.addFunctionControl(prevDec->getFunctionControl());
+        unsigned functionControl = function.getFunctionControl();
+        if (function.hasIncompatibleFunctionControl())
+            error(loc, "function attributes are incompatible", function.getName().c_str(), "");
+        if (!builtIn)
+            symbol->getAsFunction()->setFunctionControl(functionControl);
     }
 
     arrayObjectCheck(loc, function.getType(), "array in function return type");
diff --git a/glslang/MachineIndependent/ParseHelper.h b/glslang/MachineIndependent/ParseHelper.h
@@ -490,7 +490,7 @@ class TParseContext : public TParseContextBase {
     // Determine loop control from attributes
     void handleLoopAttributes(const TAttributes& attributes, TIntermNode*);
     // Function attributes
-    void handleFunctionAttributes(const TSourceLoc&, const TAttributes&);
+    void handleFunctionAttributes(const TSourceLoc&, TFunction&, const TAttributes&);
 
     // GL_EXT_spirv_intrinsics
     TSpirvRequirement* makeSpirvRequirement(const TSourceLoc& loc, const TString& name,
diff --git a/glslang/MachineIndependent/Scan.cpp b/glslang/MachineIndependent/Scan.cpp
@@ -48,6 +48,7 @@
 #include "../Include/Types.h"
 #include "SymbolTable.h"
 #include "ParseHelper.h"
+#include "Versions.h"
 #include "attribute.h"
 #include "glslang_tab.cpp.h"
 #include "ScanContext.h"
@@ -807,6 +808,8 @@ const std::unordered_map<const char*, int, str_hash, str_eq> KeywordMap {
     {"vector",VECTOR},
     {"resourceheap",RESOURCEHEAP},
     {"samplerheap",SAMPLERHEAP},
+    {"inline", INLINE},
+    {"noinline", NOINLINE},
 };
 const std::unordered_set<const char*, str_hash, str_eq> ReservedSet {
     "common",
@@ -820,8 +823,6 @@ const std::unordered_set<const char*, str_hash, str_eq> ReservedSet {
     "template",
     "this",
     "goto",
-    "inline",
-    "noinline",
     "public",
     "static",
     "extern",
@@ -2077,6 +2078,12 @@ int TScanContext::tokenizeIdentifier()
             return keyword;
         return identifierOrType();
 
+    case INLINE:
+    case NOINLINE:
+        if (!parseContext.extensionTurnedOn(E_GL_EXT_function_control_attributes))
+            return reservedWord();
+        return keyword;
+
     default:
         parseContext.infoSink.info.message(EPrefixInternalError, "Unknown glslang keyword", loc);
         return 0;
diff --git a/glslang/MachineIndependent/SymbolTable.cpp b/glslang/MachineIndependent/SymbolTable.cpp
@@ -453,6 +453,7 @@ TFunction::TFunction(const TFunction& copyOf) : TSymbol(copyOf)
     illegalImplicitThis = copyOf.illegalImplicitThis;
     defaultParamCount = copyOf.defaultParamCount;
     spirvInst = copyOf.spirvInst;
+    functionControl = copyOf.functionControl;
 }
 
 TFunction* TFunction::clone() const
diff --git a/glslang/MachineIndependent/SymbolTable.h b/glslang/MachineIndependent/SymbolTable.h
@@ -255,13 +255,14 @@ class TFunction : public TSymbol {
     explicit TFunction(TOperator o) :
         TSymbol(nullptr),
         op(o),
-        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0) { }
+        defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0),
+        functionControl(EfcNone) { }
     TFunction(const TString *name, const TType& retType, TOperator tOp = EOpNull) :
         TSymbol(name),
         mangledName(*name + '('),
         op(tOp),
         defined(false), prototyped(false), implicitThis(false), illegalImplicitThis(false), variadic(false), defaultParamCount(0),
-        linkType(ELinkNone)
+        functionControl(EfcNone), linkType(ELinkNone)
     {
         returnType.shallowCopy(retType);
         declaredBuiltIn = retType.getQualifier().builtIn;
@@ -351,6 +352,13 @@ class TFunction : public TSymbol {
 
     void setExport() { linkType = ELinkExport; }
     TLinkType getLinkType() const { return linkType; }
+    void addFunctionControl(unsigned int fc) { functionControl |= fc; }
+    void setFunctionControl(unsigned int fc) { functionControl = fc; }
+    unsigned int getFunctionControl() const { return functionControl; }
+    bool hasIncompatibleFunctionControl() const
+    {
+        return (functionControl & EfcInline) != 0 && (functionControl & EfcDontInline) != 0;
+    }
 
 protected:
     explicit TFunction(const TFunction&);
@@ -374,6 +382,7 @@ class TFunction : public TSymbol {
     int  defaultParamCount;
 
     TSpirvInstruction spirvInst; // SPIR-V instruction qualifiers
+    unsigned int functionControl;
     TLinkType linkType;
 };
 
diff --git a/glslang/MachineIndependent/Versions.cpp b/glslang/MachineIndependent/Versions.cpp
@@ -271,6 +271,7 @@ void TParseVersions::initializeExtensionBehavior()
     extensionBehavior[E_GL_EXT_expect_assume]                           = EBhDisable;
 
     extensionBehavior[E_GL_EXT_control_flow_attributes2]                = EBhDisable;
+    extensionBehavior[E_GL_EXT_function_control_attributes]             = EBhDisable;
     extensionBehavior[E_GL_EXT_spec_constant_composites]                = EBhDisable;
     extensionBehavior[E_GL_EXT_abort]                                   = EBhDisable;
 
@@ -658,6 +659,7 @@ void TParseVersions::getPreamble(std::string& preamble)
             "#define GL_EXT_texture_array 1\n"
 
             "#define GL_EXT_control_flow_attributes2 1\n"
+            "#define GL_EXT_function_control_attributes 1\n"
 
             "#define GL_EXT_integer_dot_product 1\n"
             "#define GL_EXT_bfloat16 1\n"
diff --git a/glslang/MachineIndependent/Versions.h b/glslang/MachineIndependent/Versions.h
@@ -226,6 +226,7 @@ const char* const E_GL_EXT_texture_array                    = "GL_EXT_texture_ar
 const char* const E_GL_EXT_maximal_reconvergence            = "GL_EXT_maximal_reconvergence";
 const char* const E_GL_EXT_expect_assume                    = "GL_EXT_expect_assume";
 const char* const E_GL_EXT_control_flow_attributes2         = "GL_EXT_control_flow_attributes2";
+const char* const E_GL_EXT_function_control_attributes      = "GL_EXT_function_control_attributes";
 const char* const E_GL_EXT_spec_constant_composites         = "GL_EXT_spec_constant_composites";
 const char* const E_GL_EXT_texture_offset_non_const         = "GL_EXT_texture_offset_non_const";
 const char* const E_GL_EXT_nontemporal_keyword              = "GL_EXT_nontemporal_keyword";
diff --git a/glslang/MachineIndependent/attribute.cpp b/glslang/MachineIndependent/attribute.cpp
diff --git a/glslang/MachineIndependent/attribute.h b/glslang/MachineIndependent/attribute.h
diff --git a/glslang/MachineIndependent/glslang.y b/glslang/MachineIndependent/glslang.y
diff --git a/glslang/MachineIndependent/glslang_tab.cpp b/glslang/MachineIndependent/glslang_tab.cpp
diff --git a/glslang/MachineIndependent/glslang_tab.cpp.h b/glslang/MachineIndependent/glslang_tab.cpp.h
diff --git a/gtests/Spv.FromFile.cpp b/gtests/Spv.FromFile.cpp

Original file line number	Diff line number	Diff line change
`@@ -1259,6 +1259,13 @@ TFunction* TParseContext::handleFunctionDeclarator(const TSourceLoc& loc, TFunct`
`1259`	`1259`	`}`
`1260`	`1260`	`if (!parameterTypesDiffer && prevDec->getType() != function.getType())`
`1261`	`1261`	`error(loc, "overloaded functions must have the same return type", function.getName().c_str(), "");`
	`1262`	`+`
	`1263`	`+ function.addFunctionControl(prevDec->getFunctionControl());`
	`1264`	`+ unsigned functionControl = function.getFunctionControl();`
	`1265`	`+ if (function.hasIncompatibleFunctionControl())`
	`1266`	`+ error(loc, "function attributes are incompatible", function.getName().c_str(), "");`
	`1267`	`+ if (!builtIn)`
	`1268`	`+ symbol->getAsFunction()->setFunctionControl(functionControl);`
`1262`	`1269`	`}`
`1263`	`1270`
`1264`	`1271`	`arrayObjectCheck(loc, function.getType(), "array in function return type");`