Add barrier MemoryTypeFlags and SemanticFlags diagnostics (microsoft#6513)

Context-specific diagnostics are warnings with DefaultError, since in
theory they could be dead code at this stage.

There were some changes to existing Sema diagnostic hooks along the way.

SemaHLSLDiagnoseTU.cpp - HLSLMethodCallDiagnoseVisitor
- extend to non-method calls and pass CallExpr
- instead of skipping when call reached from multiple entry/export
functions, pass locallyVisited flag for skipping of redundant diags not
dependent on entry properties.
- use llvm::SmallPtrSet for DiagnosticCalls
- capture launch type for entry and pass it down

Replace DiagnoseHLSLMethodCall hook with CheckHLSLFunctionCall:

Move hook into Sema::CheckFunctionCall in SemaChecking.cpp to be general
to either a function call or a method call.
Refactor existing code in DiagnoseHLSLMethodCall into
CheckFinishedCrossGroupSharingCall called in the hook for this method.
Add CheckBarrierCall for context-free flag validity check, called by
CheckHLSLFunctionCall.

Refactor CalculateLOD checking into more generic parts, dispatched based
on IntrinsicOp from top-level DiagnoseReachableHLSLCall function.

Switch to using new note: "entry function defined here", instead of
"declared here".

Fix intrinsic checking to use IsBuiltinTable on the intrinsic
attribute's group.

**Preparation Changes**
While these could be broken out, the barrier diagnostic changes are
dependent on them, and testing for some of these is dependent on the
other parts of the barrier diagnostic changes.

Correct errors in tests, check MaxRecords for EmptyNodeOutput in AST
Note that Barrier(..., 3) means SemanticFlags: GroupSync | GroupScope.
These are only valid in a shader with a visible group, and GroupSync on
memory with at least group scope, so they have been changed to 0 in
specific cases in these tests.

Make DiagnoseSVForLaunchType a static function, add FIXME notes.

Use StringRef for IsBuiltinTable, compare strings instead of pointers.

Fix FileCheckerTest for -verify output.

New ShaderModel::HasVisibleGroup uses ShaderKind and NodeLaunchType to
determine whether shader type has a visible group.

Author: tex3d

include/dxc/DXIL/DxilShaderModel.h

@@ -90,6 +90,18 @@ class ShaderModel {
   static const char *GetNodeLaunchTypeName(DXIL::NodeLaunchType launchTy);
   static DXIL::NodeLaunchType NodeLaunchTypeFromName(llvm::StringRef name);
 
+  static bool HasVisibleGroup(
+      DXIL::ShaderKind SK,
+      DXIL::NodeLaunchType launchType = DXIL::NodeLaunchType::Invalid) {
+    // Note: Library case is permissive; enforced at entry point.
+    return SK == DXIL::ShaderKind::Compute || SK == DXIL::ShaderKind::Mesh ||
+           SK == DXIL::ShaderKind::Amplification ||
+           SK == DXIL::ShaderKind::Library ||
+           (SK == DXIL::ShaderKind::Node &&
+            (launchType == DXIL::NodeLaunchType::Broadcasting ||
+             launchType == DXIL::NodeLaunchType::Coalescing));
+  }
+
   bool operator==(const ShaderModel &other) const;
   bool operator!=(const ShaderModel &other) const { return !(*this == other); }
 

tools/clang/include/clang/Basic/DiagnosticGroups.td

@@ -802,4 +802,5 @@ def HLSLSemanticIdentifierCollision : DiagGroup<"semantic-identifier-collision">
 def HLSLStructurizeExitsLifetimeMarkersConflict: DiagGroup<"structurize-exits-lifetime-markers-conflict">;
 def HLSLParameterUsage : DiagGroup<"parameter-usage">;
 def HLSLAvailability: DiagGroup<"hlsl-availability">;
+def HLSLBarrier : DiagGroup<"hlsl-barrier">;
 // HLSL Change Ends

tools/clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -20,6 +20,9 @@ def note_callee_decl : Note<"%0 declared here">;
 def note_defined_here : Note<"%0 defined here">;
 def note_field_declared_here : Note<"%0 field declared here">;
 
+// HLSL Change: Note for HLSL entry function location
+def note_hlsl_entry_defined_here : Note<"entry function defined here">;
+
 // For loop analysis
 def warn_variables_not_in_loop_body : Warning<
   "variable%select{s| %1|s %1 and %2|s %1, %2, and %3|s %1, %2, %3, and %4}0 "
@@ -7922,6 +7925,27 @@ def err_hlsl_outputpatch_size: Error<
 def note_hlsl_node_array : Note<"'%0' cannot be used as an array; did you mean '%0Array'?">;
 def err_hlsl_controlpoints_size: Error<
   "number of control points %0 is outside the valid range of [1..32]">;
+def err_hlsl_barrier_invalid_memory_flags: Error<
+  "invalid MemoryTypeFlags for Barrier operation; expected 0, ALL_MEMORY, or some combination of "
+  "UAV_MEMORY, GROUP_SHARED_MEMORY, NODE_INPUT_MEMORY, NODE_OUTPUT_MEMORY flags">;
+def err_hlsl_barrier_invalid_semantic_flags: Error<
+  "invalid SemanticFlags for Barrier operation; expected 0 or some combination of "
+  "GROUP_SYNC, GROUP_SCOPE, DEVICE_SCOPE flags">;
+def warn_hlsl_barrier_group_memory_requires_group: Warning<
+  "GROUP_SHARED_MEMORY specified for Barrier operation when context has no visible group">,
+  InGroup<HLSLBarrier>, DefaultError;
+def warn_hlsl_barrier_node_memory_requires_node: Warning<
+  "NODE_INPUT_MEMORY or NODE_OUTPUT_MEMORY may only be specified for Barrier operation in a node shader">,
+  InGroup<HLSLBarrier>, DefaultError;
+def warn_hlsl_barrier_group_semantic_requires_group: Warning<
+  "GROUP_SYNC or GROUP_SCOPE specified for Barrier operation when context has no visible group">,
+  InGroup<HLSLBarrier>, DefaultError;
+def warn_hlsl_barrier_no_mem_with_required_group_scope: Warning<
+  "GROUP_SCOPE specified for Barrier operation without applicable memory">,
+  InGroup<HLSLBarrier>, DefaultError;
+def warn_hlsl_barrier_no_mem_with_required_device_scope: Warning<
+  "DEVICE_SCOPE specified for Barrier operation without applicable memory">,
+  InGroup<HLSLBarrier>, DefaultError;
 // HLSL Change Ends
 
 // SPIRV Change Starts

tools/clang/include/clang/Sema/Sema.h

@@ -3807,14 +3807,13 @@ class Sema {
   void DiagnoseGloballyCoherentMismatch(const Expr *SrcExpr,
                                         QualType TargetType,
                                         SourceLocation Loc);
-  bool DiagnoseHLSLMethodCall(const CXXMethodDecl *MD, SourceLocation Loc);
-  void DiagnoseSVForLaunchType(const FunctionDecl *FD,
-                               hlsl::DXIL::NodeLaunchType LaunchTy);
-  void DiagnoseReachableHLSLMethodCall(const CXXMethodDecl *MD,
-                                       SourceLocation Loc,
-                                       const hlsl::ShaderModel *SM,
-                                       hlsl::DXIL::ShaderKind EntrySK,
-                                       const FunctionDecl *EntryDecl);
+  void CheckHLSLFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
+                             const FunctionProtoType *Proto);
+  void DiagnoseReachableHLSLCall(CallExpr *CE, const hlsl::ShaderModel *SM,
+                                 hlsl::DXIL::ShaderKind EntrySK,
+                                 hlsl::DXIL::NodeLaunchType NodeLaunchTy,
+                                 const FunctionDecl *EntryDecl,
+                                 bool locallyVisited);
   // HLSL Change Ends
 
   bool CheckUnaryExprOrTypeTraitOperand(Expr *E, UnaryExprOrTypeTrait ExprKind);

tools/clang/lib/Sema/SemaChecking.cpp

@@ -1426,6 +1426,8 @@ bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
     CheckMemaccessArguments(TheCall, CMId, FnInfo);
 #endif // HLSL Change Ends
 
+  CheckHLSLFunctionCall(FDecl, TheCall, Proto); // HLSL Change
+
   return false;
 }