[DirectX backend] Remove non-dxil string function attribute and module flag.

[python3kgae]

Summary

Remove "frame-pointer" from module flag.
For string function attribute, only keep "waveops-include-helper-lanes" and "fp32-denorm-mode" which are supported by dxil.

llvm/lib/Target/DirectX/DXILPrepare.cpp

 /// module into a module compatible with the LLVM 3.7-based DirectX Intermediate
 /// Language (DXIL).
 //===----------------------------------------------------------------------===//
 
 #include "DirectX.h"
 #include "DirectXIRPasses/PointerTypeAnalysis.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/Module.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Compiler.h"
 
return is_contained({Attribute::Alignment,
                        Attribute::SanitizeAddress,
                        Attribute::SanitizeThread,
                        Attribute::SanitizeMemory,
                        Attribute::UWTable,
                        Attribute::ZExt},
                       Attr);
 }
 
+static void collectDeadStringAttrs(AttributeMask &DeadAttrs, AttributeSet &&AS,
+                                   StringSet<> LiveKeys) {
+  for (auto &Attr : AS) {
+    if (!Attr.isStringAttribute())
+      continue;
+    StringRef Key = Attr.getKindAsString();
+    if (LiveKeys.contains(Key))
+      continue;
+    DeadAttrs.addAttribute(Key);
+  }
+}
+
+static void removeStringFunctionAttributes(Function &F) {
+  AttributeList Attrs = F.getAttributes();
+  StringSet<> LiveKeys = {"waveops-include-helper-lanes"
+                          "fp32-denorm-mode"};
+  // Collect DeadKeys in FnAttrs.
+  AttributeMask DeadAttrs;
+  collectDeadStringAttrs(DeadAttrs, Attrs.getFnAttrs(), LiveKeys);
+  collectDeadStringAttrs(DeadAttrs, Attrs.getRetAttrs(), LiveKeys);
+
+  F.removeFnAttrs(DeadAttrs);
+  F.removeRetAttrs(DeadAttrs);
+}
+
+static void cleanModuleFlags(Module &M) {
+  constexpr StringLiteral DeadKeys[] = {"frame-pointer"};
+  // Collect DeadKeys in ModuleFlags.
+  StringSet<> DeadKeySet;
+  for (auto &Key : DeadKeys) {
+    if (M.getModuleFlag(Key))
+      DeadKeySet.insert(Key);
+  }
+  if (DeadKeySet.empty())
+    return;
+
+  SmallVector<Module::ModuleFlagEntry, 8> ModuleFlags;
+  M.getModuleFlagsMetadata(ModuleFlags);
+  NamedMDNode *MDFlags = M.getModuleFlagsMetadata();
+  MDFlags->eraseFromParent();
+  // Add ModuleFlag which not dead.
+  for (auto &Flag : ModuleFlags) {
+    StringRef Key = Flag.Key->getString();
+    if (DeadKeySet.contains(Key))
+      continue;
+    M.addModuleFlag(Flag.Behavior, Key, Flag.Val);
+  }
+}
+
 class DXILPrepareModule : public ModulePass {
 
   static Value *maybeGenerateBitcast(IRBuilder<> &Builder,
                                      PointerTypeMap &PointerTypes,
                                      Instruction &Inst, Value *Operand,
                                      Type *Ty) {
     // Omit bitcasts if the incoming value matches the instruction type.
     auto It = PointerTypes.find(Operand);
bool runOnModule(Module &M) override {
     for (Attribute::AttrKind I = Attribute::None; I != Attribute::EndAttrKinds;
          I = Attribute::AttrKind(I + 1)) {
       if (!isValidForDXIL(I))
         AttrMask.addAttribute(I);
     }
     for (auto &F : M.functions()) {
       F.removeFnAttrs(AttrMask);
       F.removeRetAttrs(AttrMask);
+      removeStringFunctionAttributes(F);
       for (size_t Idx = 0, End = F.arg_size(); Idx < End; ++Idx)
         F.removeParamAttrs(Idx, AttrMask);
 
       for (auto &BB : F) {
         IRBuilder<> Builder(&BB);
         for (auto &I : make_early_inc_range(BB)) {
           if (I.getOpcode() == Instruction::FNeg) {
             Builder.SetInsertPoint(&I);
for (auto &F : M.functions()) {
             CB->removeRetAttrs(AttrMask);
             for (size_t Idx = 0, End = CB->arg_size(); Idx < End; ++Idx)
               CB->removeParamAttrs(Idx, AttrMask);
             continue;
           }
         }
       }
     }
+    // Remove flags not in llvm3.7.
+    cleanModuleFlags(M);
     return true;
   }
 
   DXILPrepareModule() : ModulePass(ID) {}
 
   static char ID; // Pass identification.
 };
 char DXILPrepareModule::ID = 0;

llvm/test/CodeGen/DirectX/clean_string_attr.ll

+; RUN: opt -S -dxil-prepare < %s | FileCheck %s
+
+; Make sure function attribute like "frame-pointer" is removed.
+; CHECK:attributes #0 = { nounwind memory(readwrite, inaccessiblemem: read) }
+
+; Make sure "frame-pointer" is removed from module flags.
+; CHECK:!llvm.module.flags = !{![[SIZE:[0-9]+]]}
+; CHECK:![[SIZE]] = !{i32 1, !"wchar_size", i32 4}
+
+target datalayout = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64"
+target triple = "dxil-unknown-shadermodel6.0-compute"
+
+; Function Attrs: mustprogress nofree nounwind willreturn memory(readwrite, inaccessiblemem: read)
+define void @CSMain() local_unnamed_addr #0 {
+  ret void
+}
+
+attributes #0 = { mustprogress nofree nounwind willreturn memory(readwrite, inaccessiblemem: read) "frame-pointer"="all" "hlsl.numthreads"="1024,1,1" "hlsl.shader"="compute" "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+
+!llvm.module.flags = !{!0, !1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{i32 7, !"frame-pointer", i32 2}

llvm/test/tools/dxil-dis/attribute-filter.ll

 ; CHECK: Function Attrs: readnone
 ; Function Attrs: norecurse readnone willreturn
 define float @fma2(float %0, float %1, float %2) #1 {
   %4 = fmul float %0, %1
   %5 = fadd float %4, %2
   ret float %5
 }
 
-; CHECK: attributes #0 = { nounwind readnone "disable-tail-calls"="false" }
+; CHECK: attributes #0 = { nounwind readnone }
 attributes #0 = { norecurse nounwind readnone willreturn "disable-tail-calls"="false" }
 
-; CHECK: attributes #1 = { readnone "disable-tail-calls"="false" }
+; CHECK: attributes #1 = { readnone }
 attributes #1 = { norecurse memory(none) willreturn "disable-tail-calls"="false" }