Revert NFC changes to reduce changeset size.

Author: bharadwajy

llvm/lib/Target/DirectX/DXIL.td

@@ -275,7 +275,7 @@ class Stages<list<ShaderStage> st> : Pred {
 }
 
 // Following class represents predicate that evaluates to the payload when
-// specified predicte is true.
+// specified predicate is true.
 
 class Constraints<Pred p, list<Pred> l = []> : Pred {
   Pred pred = p;

llvm/lib/Target/DirectX/DXILOpBuilder.cpp

@@ -59,7 +59,7 @@ static OverloadKind getOverloadKind(Type *Ty) {
     }
   }
   case Type::PointerTyID:
-    return OverloadKind::UserDefinedType;
+    return OverloadKind::UserDefineType;
   case Type::StructTyID:
     return OverloadKind::ObjectType;
   default:
@@ -69,9 +69,9 @@ static OverloadKind getOverloadKind(Type *Ty) {
 }
 
 static std::string getTypeName(OverloadKind Kind, Type *Ty) {
-  if (Kind < OverloadKind::UserDefinedType) {
+  if (Kind < OverloadKind::UserDefineType) {
     return getOverloadTypeName(Kind);
-  } else if (Kind == OverloadKind::UserDefinedType) {
+  } else if (Kind == OverloadKind::UserDefineType) {
     StructType *ST = cast<StructType>(Ty);
     return ST->getStructName().str();
   } else if (Kind == OverloadKind::ObjectType) {
@@ -100,7 +100,7 @@ static std::string constructOverloadTypeName(OverloadKind Kind,
   if (Kind == OverloadKind::VOID)
     return TypeName.str();
 
-  assert(Kind < OverloadKind::UserDefinedType && "invalid overload kind");
+  assert(Kind < OverloadKind::UserDefineType && "invalid overload kind");
   return (Twine(TypeName) + getOverloadTypeName(Kind)).str();
 }
 
@@ -340,7 +340,7 @@ CallInst *DXILOpBuilder::createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
   return B.CreateCall(DXILFn, Args);
 }
 
-Type *DXILOpBuilder::getOverloadType(dxil::OpCode OpCode, FunctionType *FT) {
+Type *DXILOpBuilder::getOverloadTy(dxil::OpCode OpCode, FunctionType *FT) {
 
   const OpCodeProperty *Prop = getOpCodeProperty(OpCode);
   // If DXIL Op has no overload parameter, just return the

llvm/lib/Target/DirectX/DXILOpBuilder.h

@@ -14,8 +14,6 @@
 
 #include "DXILConstants.h"
 #include "llvm/ADT/SmallVector.h"
-#include "llvm/Support/DXILABI.h"
-#include "llvm/Support/VersionTuple.h"
 namespace llvm {
 class Module;
 class IRBuilderBase;
@@ -43,7 +41,7 @@ class DXILOpBuilder {
   CallInst *createDXILOpCall(dxil::OpCode OpCode, Type *ReturnTy,
                              Type *OverloadTy, SmallVector<Value *> Args);
 
-  Type *getOverloadType(dxil::OpCode OpCode, FunctionType *FT);
+  Type *getOverloadTy(dxil::OpCode OpCode, FunctionType *FT);
   static const char *getOpCodeName(dxil::OpCode DXILOp);
 
 private:

llvm/lib/Target/DirectX/DXILOpLowering.cpp

@@ -22,10 +22,8 @@
 #include "llvm/IR/IntrinsicsDirectX.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManager.h"
-#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/ErrorHandling.h"
-#include <string>
 
 #define DEBUG_TYPE "dxil-op-lower"
 
@@ -77,7 +75,7 @@ static SmallVector<Value *> argVectorFlatten(CallInst *Orig,
 static void lowerIntrinsic(dxil::OpCode DXILOp, Function &F, Module &M) {
   IRBuilder<> B(M.getContext());
   DXILOpBuilder DXILB(M, B);
-  Type *OverloadTy = DXILB.getOverloadType(DXILOp, F.getFunctionType());
+  Type *OverloadTy = DXILB.getOverloadTy(DXILOp, F.getFunctionType());
   for (User *U : make_early_inc_range(F.users())) {
     CallInst *CI = dyn_cast<CallInst>(U);
     if (!CI)

llvm/utils/TableGen/DXILEmitter.cpp

@@ -25,6 +25,7 @@
 #include "llvm/TableGen/Record.h"
 #include "llvm/TableGen/TableGenBackend.h"
 
+#include <cstddef>
 #include <string>
 #include <vector>
 
@@ -108,7 +109,7 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
   for (auto Ty : ArgTys) {
     ParamTypeRecs.push_back(Ty);
   }
-  unsigned ParamTypeRecsSize = ParamTypeRecs.size();
+  size_t ParamTypeRecsSize = ParamTypeRecs.size();
   // Populate OpTypes with return type and parameter types
 
   // Parameter indices of overloaded parameters.
@@ -120,23 +121,23 @@ DXILOperationDesc::DXILOperationDesc(const Record *R) {
   for (unsigned I = 0; I < ParamTypeRecsSize; I++) {
     auto TR = ParamTypeRecs[I];
     // Track operation parameter indices of any overload types
-    auto IsAny = TR->getValueAsInt("isAny");
-    if (IsAny == 1) {
-      // TODO: At present it is expected that all overload types in a DXIL Op
+    auto isAny = TR->getValueAsInt("isAny");
+    if (isAny == 1) {
+      // It is expected that all overload types in a DXIL Op
       // are of the same type. Hence, OverloadParamIndices will have only one
       // element. This implies we do not need a vector. However, until more
       // (all?) DXIL Ops are added in DXIL.td, a vector is being used to flag
       // cases this assumption would not hold.
       if (!OverloadParamIndices.empty()) {
-        bool KnownType = true;
+        bool knownType = true;
         // Ensure that the same overload type registered earlier is being used
         for (auto Idx : OverloadParamIndices) {
           if (TR != ParamTypeRecs[Idx]) {
-            KnownType = false;
+            knownType = false;
             break;
           }
         }
-        assert(KnownType && "Specification of multiple differing overload "
+        assert(knownType && "Specification of multiple differing overload "
                             "parameter types not yet supported");
       } else {
         OverloadParamIndices.push_back(I);
@@ -506,7 +507,6 @@ static void emitDXILOperationTable(std::vector<DXILOperationDesc> &Ops,
        << Op.OverloadParamIndex << ", " << Op.OpTypes.size() - 1 << ", "
        << Parameters.get(ParameterMap[Op.OpClass]) << " }";
     Prefix = ",\n";
-    // OS << "\n// " << getConstraintString(Op.Constraints) << "\n";
   }
   OS << "  };\n";
 
@@ -599,7 +599,7 @@ static void emitDXILOperationTableDataStructs(RecordKeeper &Records,
   // Emit enum OverloadKind with valid overload types.
   const SmallVector<std::string> OverloadKindList = {
       "VOID", "HALF", "FLOAT", "DOUBLE",          "I1",        "I8",
-      "I16",  "I32",  "I64",   "UserDefinedType", "ObjectType"};
+      "I16",  "I32",  "I64",   "UserDefineType", "ObjectType"};
   // Choose the type of enum OverloadKind based on the number of valid types in
   // OverloadKindList. This gives the flexibility to just add new supported
   // types to the list above, if needed, with no need to change this backend
@@ -667,7 +667,7 @@ static void emitDXILOperationTableDataStructs(RecordKeeper &Records,
     case OverloadKind::UNDEFINED:  \n \
       return \"void\";  \n \
     case OverloadKind::ObjectType: \n \
-    case OverloadKind::UserDefinedType: \n \
+    case OverloadKind::UserDefineType: \n \
       break; \n \
     } \n \
     llvm_unreachable(\"invalid overload type for name\"); \n \