Add DXILPrepare CodeGen pass

[beanz]

Summary

The DXIL Prepare pass handles the IR mutations required to convert
modern LLVM IR into something that more closely resembles LLVM-3.7 IR
so that the DXIL bitcode writer can emit 3.7 IR.

This change adds the codegen pass handling the first two IR
transformations:

• stripping new function attributes
• converting fneg into fsub

[nikic]

llvm/lib/Target/DirectX/DXILPrepare.cpp

65

Do you really need Attributes.inc here? You should be able to loop over all attributes using Attribute::None and Attribute::EndAttrKind.

76

Shouldn't this be negative zero?

[beanz]

llvm/lib/Target/DirectX/DXILPrepare.cpp

65

I don't strictly need it, but if isValidForDXIL gets called with a constant it should get constant-folded to true/false. That isn't the case if I call it in a loop.

76

Yep, you are 100% correct. Will update.

[arsenm]

llvm/lib/Target/DirectX/DXILPrepare.cpp

77

Well this is a semantically wrong substitution

[nikic]

llvm/lib/Target/DirectX/DXILPrepare.cpp

65

You can construct an AttributeMask with all the invalid attributes upfront, and then remove that mask, rather than removing each attribute individually. In that case, constant folding shouldn't matter, and you can probably drop D122079 entirely.

[beanz]

Update to use an AttributeMask instead of Attributes.inc expansion, and correct fneg replacement.

[rnk]

Seems reasonable

llvm/lib/Target/DirectX/DXILPrepare.cpp

49

It's amusing to consider the implications of sanitizer attributes on DXIL. :) (no action required)

65

(This is already resolved, but in general, strong +1 to more data, less generated code.)

80

If an fneg uses an fneg, there's a potential use-after-free here. The recommended best practice is to accumulate instructions and delete them after the loop to avoid modification during iteration. I *think* it's safe to do the insertion during iteration. There's also the early_inc iterator: https://reviews.llvm.org/D49956

Anyway, you've got options.

[beanz]

llvm/lib/Target/DirectX/DXILPrepare.cpp

49

Very much so. I think sanitizer support for HLSL and GPU programs more generally is _very_ interesting :)

[beanz]

Updating to address PR feedback.

[beanz]

Rebasing on main now that the dependent changes have landed.

[nikic]

llvm/lib/Target/DirectX/DXILPrepare.cpp

98

Why the three loops here? I think you just need one if you use make_early_inc_range.

llvm/lib/Target/DirectX/DirectX.h

15

This include looks unnecessary given the forward declaration below.

[beanz]

Updating based on PR feedback from @nikic.

Thank you!

[nikic]

LGTM

llvm/lib/Target/DirectX/CMakeLists.txt

 add_llvm_component_group(DirectX)
 
 set(LLVM_TARGET_DEFINITIONS DirectX.td)
 
 tablegen(LLVM DirectXGenSubtargetInfo.inc -gen-subtarget)
 
 add_public_tablegen_target(DirectXCommonTableGen)
 
 add_llvm_target(DirectXCodeGen
   DirectXSubtarget.cpp
   DirectXTargetMachine.cpp
+  DXILPrepare.cpp
 
   LINK_COMPONENTS
   Bitwriter
   Core
   Support
   DirectXInfo
 
   ADD_TO_COMPONENT
   DirectX
 )
 
 add_subdirectory(MCTargetDesc)
 add_subdirectory(TargetInfo)

llvm/lib/Target/DirectX/DXILPrepare.cpp

+//===- DXILPrepare.cpp - Prepare LLVM Module for DXIL encoding ------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file This file contains pases and utilities to convert a modern LLVM
+/// module into a module compatible with the LLVM 3.7-based DirectX Intermediate
+/// Language (DXIL).
+//===----------------------------------------------------------------------===//
+
+#include "DirectX.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/ADT/SmallVector.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"
+
+#define DEBUG_TYPE "dxil-prepare"
+
+using namespace llvm;
+
+namespace {
+
+constexpr bool isValidForDXIL(Attribute::AttrKind Attr) {
+  return is_contained({Attribute::Alignment,
+                       Attribute::AlwaysInline,
+                       Attribute::Builtin,
+                       Attribute::ByVal,
+                       Attribute::InAlloca,
+                       Attribute::Cold,
+                       Attribute::Convergent,
+                       Attribute::InlineHint,
+                       Attribute::InReg,
+                       Attribute::JumpTable,
+                       Attribute::MinSize,
+                       Attribute::Naked,
+                       Attribute::Nest,
+                       Attribute::NoAlias,
+                       Attribute::NoBuiltin,
+                       Attribute::NoCapture,
+                       Attribute::NoDuplicate,
+                       Attribute::NoImplicitFloat,
+                       Attribute::NoInline,
+                       Attribute::NonLazyBind,
+                       Attribute::NonNull,
+                       Attribute::Dereferenceable,
+                       Attribute::DereferenceableOrNull,
+                       Attribute::NoRedZone,
+                       Attribute::NoReturn,
+                       Attribute::NoUnwind,
+                       Attribute::OptimizeForSize,
+                       Attribute::OptimizeNone,
+                       Attribute::ReadNone,
+                       Attribute::ReadOnly,
+                       Attribute::ArgMemOnly,
+                       Attribute::Returned,
+                       Attribute::ReturnsTwice,
+                       Attribute::SExt,
+                       Attribute::StackAlignment,
+                       Attribute::StackProtect,
+                       Attribute::StackProtectReq,
+                       Attribute::StackProtectStrong,
+                       Attribute::SafeStack,
+                       Attribute::StructRet,
+                       Attribute::SanitizeAddress,
+                       Attribute::SanitizeThread,
+                       Attribute::SanitizeMemory,
+                       Attribute::UWTable,
+                       Attribute::ZExt},
+                      Attr);
+}
+
+class DXILPrepareModule : public ModulePass {
+public:
+  bool runOnModule(Module &M) override {
+    AttributeMask AttrMask;
+    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);
+      for (size_t Idx = 0; Idx < F.arg_size(); ++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);
+            Value *In = I.getOperand(0);
+            Value *Zero = ConstantFP::get(In->getType(), -0.0);
+            I.replaceAllUsesWith(Builder.CreateFSub(Zero, In));
+            I.eraseFromParent();
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  DXILPrepareModule() : ModulePass(ID) {}
+
+  static char ID; // Pass identification.
+};
+char DXILPrepareModule::ID = 0;
+
+} // end anonymous namespace
+
+INITIALIZE_PASS_BEGIN(DXILPrepareModule, DEBUG_TYPE, "DXIL Prepare Module",
+                      false, false)
+INITIALIZE_PASS_END(DXILPrepareModule, DEBUG_TYPE, "DXIL Prepare Module", false,
+                    false)
+
+ModulePass *llvm::createDXILPrepareModulePass() {
+  return new DXILPrepareModule();
+}

llvm/lib/Target/DirectX/DirectX.h

+//===- DirectXTargetMachine.h - DirectX Target Implementation ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_DIRECTX_DIRECTX_H
+#define LLVM_LIB_TARGET_DIRECTX_DIRECTX_H
+
+namespace llvm {
+class ModulePass;
+class PassRegistry;
+
+/// Initializer for DXIL-prepare
+void initializeDXILPrepareModulePass(PassRegistry &);
+
+/// Pass to convert modules into DXIL-compatable modules
+ModulePass *createDXILPrepareModulePass();
+} // namespace llvm
+
+#endif // LLVM_LIB_TARGET_DIRECTX_DIRECTX_H

llvm/lib/Target/DirectX/DirectXTargetMachine.cpp

 //===- DirectXTargetMachine.cpp - DirectX Target Implementation -*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file contains DirectX target initializer.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "DirectXTargetMachine.h"
+#include "DirectX.h"
 #include "DirectXSubtarget.h"
 #include "DirectXTargetTransformInfo.h"
 #include "TargetInfo/DirectXTargetInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 using namespace llvm;
 
 extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeDirectXTarget() {
   RegisterTargetMachine<DirectXTargetMachine> X(getTheDirectXTarget());
+  auto *PR = PassRegistry::getPassRegistry();
+  initializeDXILPrepareModulePass(*PR);
 }
 
 class DXILTargetObjectFile : public TargetLoweringObjectFile {
 public:
   DXILTargetObjectFile() = default;
 
   MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override {
: LLVMTargetMachine(T,
       Subtarget(std::make_unique<DirectXSubtarget>(TT, CPU, FS, *this)) {}
 
 DirectXTargetMachine::~DirectXTargetMachine() {}
 
 bool DirectXTargetMachine::addPassesToEmitFile(
     PassManagerBase &PM, raw_pwrite_stream &Out, raw_pwrite_stream *DwoOut,
     CodeGenFileType FileType, bool DisableVerify,
     MachineModuleInfoWrapperPass *MMIWP) {
+  PM.add(createDXILPrepareModulePass());
   switch (FileType) {
   case CGFT_AssemblyFile:
     PM.add(createPrintModulePass(Out, "", true));
     break;
   case CGFT_ObjectFile:
     // TODO: Write DXIL instead of bitcode
     PM.add(createBitcodeWriterPass(Out, true, false, false));
     break;

llvm/test/CodeGen/DirectX/fneg-conversion.ll

+; RUN: llc %s --filetype=asm -o - | FileCheck %s
+target triple = "dxil-unknown-unknown"
+
+define float @negateF(float %0) {
+; CHECK:  %2 = fsub float -0.000000e+00, %0
+  %2 = fneg float %0
+  ret float %2
+}
+
+define double @negateD(double %0) {
+; CHECK: %2 = fsub double -0.000000e+00, %0
+  %2 = fneg double %0
+  ret double %2
+}

llvm/test/CodeGen/DirectX/lit.local.cfg

+if not 'DirectX' in config.root.targets:
+  config.unsupported = True

llvm/test/CodeGen/DirectX/strip-fn-attrs.ll

+; RUN: llc %s --filetype=asm -o - | FileCheck %s
+target triple = "dxil-unknown-unknown"
+
+; CHECK: Function Attrs: nounwind readnone
+; Function Attrs: norecurse nounwind readnone willreturn
+define dso_local float @fma(float %0, float %1, float %2) local_unnamed_addr #0 {
+  %4 = fmul float %0, %1
+  %5 = fadd float %4, %2
+  ret float %5
+}
+
+; CHECK: Function Attrs: nounwind readnone
+; Function Attrs: nofree nosync nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+; CHECK: attributes #0 = { nounwind readnone }
+; CHECK-NOT attributes #
+
+attributes #0 = { norecurse nounwind readnone willreturn }
+attributes #1 = { nofree nosync nounwind readnone speculatable willreturn }