[OpaquePointers] Rewrite the type scavenger. (#1957)

This is a massive change, which consists of the following pieces that are not so easily seperable (why this is a large, single commit instead of many smaller ones):

Use typed pointer types in the external interface of the scavenger.
Use target extension types in lieu of DeferredType to represent types not yet known. These types are now target("typevar", N), where N is some integer.
Use TypedPointerType in lieu of DeducedType. This makes multi-level pointer types simpler to use.
Replace std::pair<unsigned, DeducedType> with a more generalized TypeRule class, which simplifies some of the rules for the typing procedure.
Make computePointerElementType and correctUseTypes both rely on the same list of type rules, removing duplication.
Add support for vectors of pointers, arrays of pointers, and function pointers in the type scavenger.
Allow global variables to have scavenged types.
Allow return types to not be i8*.
Add more documentation of the type scavenger process.
More tests!
Miscellaneous type rule fixes.
Overall, the logic of the type scavenger largely remains unchanged (albeit with increased functionality), but the way that logic is expressed has changed very significantly, and the easier functionality for handling a few cases causes shifting of expected bitcast placements in existing tests.

Author: jcranmer-intel

lib/SPIRV/SPIRVTypeScavenger.cpp

@@ -41,52 +41,138 @@
 #ifndef SPIRVTYPESCAVENGER_H
 #define SPIRVTYPESCAVENGER_H
 
+#include "llvm/ADT/IntEqClasses.h"
 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/ValueMap.h"
 
 using namespace llvm;
 
-/// This class allows for the recovery of pointer element types from LLVM
-/// opaque pointer types.
+/// This class allows for the recovery of typed pointer types from LLVM opaque
+/// pointer types. A detailed description of how this algorithm works may be
+/// found in the file comment of SPIRVTypeScavenger.cpp.
 class SPIRVTypeScavenger {
-  /// A representation of a pointer whose type will be determined by uses. This
-  /// will include every value that needs to be assigned the same type.
-  struct DeferredType {
-    std::vector<Value *> Values;
+  /// The mapping from type variables to concrete types.
+  std::vector<Type *> TypeVariables;
+
+  /// The structure storing which type variables have been unified.
+  IntEqClasses UnifiedTypeVars;
+
+  /// Replace all ptr types found within T with new type variables.
+  Type *allocateTypeVariable(Type *T);
+
+  /// Replace all type variables found within T with their concrete types. If
+  /// the type variable doesn't have a concrete type yet, the type variable will
+  /// be retained.
+  Type *substituteTypeVariables(Type *T);
+
+  /// Try to resolve all type variables into concrete types using knowledge that
+  /// T1 and T2 have to be the same type. If T1 and T2 cannot be made the same
+  /// type, return false (and callers will know they need to insert synthetic
+  /// bitcasts to guarantee equality).
+  bool unifyType(Type *T1, Type *T2);
+
+  /// This stores the Value -> corrected type mapping for the module. It is
+  /// expected that all instructions, arguments, and global values will appear
+  /// in this mapping, while constants are not expected to be listed here.
+  ValueMap<Value *, Type *> DeducedTypes;
+
+  /// Store associated type variables for certain instructions. In the case
+  /// where a return value has an association with an operand, it's necessary
+  /// that the type variable used to generate type rules be the same for all
+  /// invocations of getTypeRules. This variable allows storage of such
+  /// variables.
+  ValueMap<Value *, Type *> AssociatedTypeVariables;
+
+  /// A type rule, which expresses that the given operand of a User must have
+  /// the given type (which may contain type variables).
+  struct TypeRule {
+    unsigned OpNo;
+    bool LhsIndirect;
+    bool RhsIndirect;
+    PointerUnion<Type *, Use *> Target;
+    TypeRule(unsigned A, bool AIndirect, Type *B, bool BIndirect)
+        : OpNo(A), LhsIndirect(AIndirect), RhsIndirect(BIndirect), Target(B) {}
+    TypeRule(unsigned A, bool AIndirect, Use *B, bool BIndirect)
+        : OpNo(A), LhsIndirect(AIndirect), RhsIndirect(BIndirect), Target(B) {}
+
+    /// Establishes typeof(operand) == concrete type
+    static TypeRule is(unsigned OpIndex, Type *Ty) {
+      return TypeRule(OpIndex, false, Ty, false);
+    }
+    /// Establishes typeof(operand) == concrete type
+    static TypeRule is(Use &U, Type *Ty) {
+      return TypeRule::is(U.getOperandNo(), Ty);
+    }
+    /// Establishes typeof(operand) == typeof(operand)
+    static TypeRule is(User &U, unsigned Op1, unsigned Op2) {
+      return TypeRule(Op1, false, &U.getOperandUse(Op2), false);
+    }
+    /// Establishes typedptr(typeof(operand)) == typedptr(typeof(operand))
+    /// (this is useful when the address spaces do not need to match).
+    static TypeRule isIndirect(User &U, unsigned Op1, unsigned Op2) {
+      return TypeRule(Op1, true, &U.getOperandUse(Op2), true);
+    }
+    /// Establishes typeof(operand) == typedptr(concrete type)
+    static TypeRule pointsTo(Use &U, Type *Ty) {
+      return TypeRule(U.getOperandNo(), false, Ty, true);
+    }
+    /// Establishes typeof(operand) == typedptr(concrete type)
+    static TypeRule pointsTo(User &U, unsigned OpIndex, Type *Ty) {
+      return TypeRule::pointsTo(U.getOperandUse(OpIndex), Ty);
+    }
+    /// Establishes typeof(mem operand) == typedptr(typeof(val operand))
+    static TypeRule pointsTo(User &U, unsigned MemIndex, unsigned ValIndex) {
+      return TypeRule(MemIndex, false, &U.getOperandUse(ValIndex), true);
+    }
+    /// Establishes typeof(operand) == typedptr(typeof(return))
+    static TypeRule pointsToReturn(User &U, unsigned OpIndex) {
+      return TypeRule(RETURN_OPERAND, true, &U.getOperandUse(OpIndex), false);
+    }
+    /// Establishes typeof(return) == concrete type
+    static TypeRule returns(Type *Ty) {
+      return TypeRule(RETURN_OPERAND, false, Ty, false);
+    }
+    /// Establishes typeof(return) == typedptr(concrete type)
+    static TypeRule returnsPointerTo(Type *Ty) {
+      return TypeRule(RETURN_OPERAND, false, Ty, true);
+    }
+    /// Establishes typeof(return) == typeof(operand)
+    static TypeRule propagates(Use &U) {
+      return TypeRule(RETURN_OPERAND, false, &U, false);
+    }
+    /// Establishes typeof(return) == typeof(operand)
+    static TypeRule propagates(User &U, unsigned OpIndex) {
+      return TypeRule::propagates(U.getOperandUse(OpIndex));
+    }
+    /// Establishes typedptr(typeof(return)) == typedptr(typeof(operand))
+    static TypeRule propagatesIndirect(Use &U) {
+      return TypeRule(RETURN_OPERAND, true, &U, true);
+    }
+    /// Establishes typedptr(typeof(return)) == typedptr(typeof(operand))
+    static TypeRule propagatesIndirect(User &U, unsigned OpIndex) {
+      return TypeRule::propagatesIndirect(U.getOperandUse(OpIndex));
+    }
   };
 
-  /// This is called when a deferred type is fixed to a known use.
-  void fixType(DeferredType &Deferred, Type *AssignedType);
-
-  /// This merges two deferred types into one deferred type.
-  void mergeType(DeferredType *A, DeferredType *B);
-
-  /// A representation of the possible states of a type internal to this pass:
-  /// it may be either
-  /// * Something with a fixed LLVM type (this is a Type *)
-  /// * A type whose pointer element type is yet unknown (DeferredType *)
-  /// * A multi-level pointer type (this is a Value *, whose type is what this
-  ///   pointer type will point to). The latter should only exist for
-  ///   pointer operands of memory operations that return ptr.
-  typedef PointerUnion<Type *, DeferredType *, Value *> DeducedType;
-  friend llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, DeducedType Ty) {
-    if (auto *AsTy = dyn_cast<Type *>(Ty))
-      return OS << *AsTy;
-    if (auto *AsDeferred = dyn_cast<DeferredType *>(Ty))
-      return OS << "deferred type for " << *AsDeferred->Values[0];
-    if (auto *AsValue = dyn_cast<Value *>(Ty))
-      return OS << "points to " << *AsValue;
-    return OS;
-  }
+  /// This is a value that allows the ability to express the type of a value as
+  /// a whole in a typing rule.
+  static constexpr unsigned RETURN_OPERAND = ~0U;
+
+  /// Turn a type rule into an operand and a type to check for. If the type of
+  /// the operand and the type to check against cannot be unified, then a
+  /// bitcast will need to be inserted for the use.
+  std::pair<Use &, Type *> getTypeCheck(Instruction &I, const TypeRule &Rule);
 
-  /// Compute the pointer element type of a value, solely based on its
-  /// definition. The value must be pointer-valued.
-  DeducedType computePointerElementType(Value *V);
+  /// Retrieve the list of typing rules for an instruction.
+  void getTypeRules(Instruction &I, SmallVectorImpl<TypeRule> &Rules);
 
-  /// This stores the Value -> pointer element type mapping for the module.
-  ValueMap<Value *, DeducedType> DeducedTypes;
+  /// Get the best guess for the type of the value, applying any type rules to
+  /// the return value of an instruction that exist. The return type may refer
+  /// to type variables that have yet to be resolved, if the type rules are
+  /// insufficient to establish a typed pointer type for the instruction.
+  Type *getTypeAfterRules(Value *V);
 
   /// Enforce that the pointer element types of all operands of the instruction
   /// matches the type that the instruction itself requires. If a pointer
@@ -99,17 +185,21 @@ class SPIRVTypeScavenger {
   /// analysis on the module.
   void deduceFunctionType(Function &F);
 
-  /// This computes the known types of a call to an LLVM intrinsic or specific
-  /// well-known function name. Returns true if the call filled in type
-  /// information.
-  ///
-  /// The ArgTys parameter contains a list of known type uses for the parameters
-  /// of the function call. Each element is a pair, with the first being the
-  /// operand number, and the second indicating either a known type or an
-  /// unknown type variable (DeferredType).
-  bool
-  typeIntrinsicCall(CallBase &CB,
-                    SmallVectorImpl<std::pair<unsigned, DeducedType>> &ArgTys);
+  /// This computes known type rules of a call to an LLVM intrinsic or specific
+  /// well-known function name. Returns true if the call was known to this
+  /// function.
+  bool typeIntrinsicCall(CallBase &CB, SmallVectorImpl<TypeRule> &TypeRules);
+
+  /// Get the type rules for checking argument and return value compatibility
+  /// for the function type being called. This is meant to help unify cases
+  /// for indirect function calls.
+  void typeFunctionParams(CallBase &CB, FunctionType *FT, unsigned ArgStart,
+                          bool IncludeRet,
+                          SmallVectorImpl<TypeRule> &TypeRules);
+
+  /// Compute the type of a global variable or global alias, based on the type
+  /// of the initializer (which may be null for global variables).
+  void typeGlobalValue(GlobalValue &GV, Constant *Init);
 
   /// Compute pointer element types for all pertinent values in the module.
   void typeModule(Module &M);
@@ -119,24 +209,17 @@ class SPIRVTypeScavenger {
   std::vector<Value *> VisitStack;
 
 public:
-  explicit SPIRVTypeScavenger(Module &M) { typeModule(M); }
-
-  /// This type represents the type that a pointer element type of a type. If it
-  /// is a Type value, then the pointee type represents a pointer to that type.
-  /// If it is a Value value, then the pointee type is the type of that value
-  /// (which should be a pointer-typed value.)
-  typedef PointerUnion<Type *, Value *> PointeeType;
-
-  /// Get the pointer element type of the value.
-  /// If the type is a multi-level pointer, then PointeeType will be a Value
-  /// whose pointee type can be recursively queried through this method.
-  /// Otherwise, it will be a pointer to the Type returned by this method.
-  PointeeType getPointerElementType(Value *V);
-
-  /// Get the pointer element type of an argument of the given function. Since
-  /// this type is guaranteed to not be a multi-level pointer type, the result
-  /// is an LLVM type instead of a PointeeType.
-  Type *getArgumentPointerElementType(Function *F, unsigned ArgNo);
+  explicit SPIRVTypeScavenger(Module &M) : UnifiedTypeVars(1024) {
+    typeModule(M);
+  }
+
+  /// Get the type of the value, with pointer types replaced with
+  /// TypedPointerType types instead.
+  Type *getScavengedType(Value *V);
+
+  /// Get the deduced function type for a function, with pointer types replaced
+  /// with TypedPointerTypes (maybe including type variables).
+  FunctionType *getFunctionType(Function *F);
 };
 
 #endif // SPIRVTYPESCAVENGER_H

lib/SPIRV/SPIRVTypeScavenger.h

@@ -818,11 +818,12 @@ bool getParameterTypes(Function *F, SmallVectorImpl<Type *> &ArgTys,
       assert(!HasSret && &Arg == F->getArg(0) &&
              "sret parameter should only appear on the first argument");
       HasSret = true;
+      unsigned AS = Arg.getType()->getPointerAddressSpace();
       if (auto *STy = dyn_cast<StructType>(Ty))
         ArgTys.push_back(
-            TypedPointerType::get(GetStructType(STy->getName()), 0));
+            TypedPointerType::get(GetStructType(STy->getName()), AS));
       else
-        ArgTys.push_back(TypedPointerType::get(Ty, 0));
+        ArgTys.push_back(TypedPointerType::get(Ty, AS));
     } else {
       ArgTys.push_back(Arg.getType());
     }
@@ -893,6 +894,11 @@ bool getParameterTypes(Function *F, SmallVectorImpl<Type *> &ArgTys,
       DemangledSuccessfully = false;
     } else if (ArgTy->isTargetExtTy() || !DemangledTy)
       DemangledTy = ArgTy;
+    if (auto *TPT = dyn_cast<TypedPointerType>(DemangledTy))
+      if (ArgTy->isPointerTy() &&
+          TPT->getAddressSpace() != ArgTy->getPointerAddressSpace())
+        DemangledTy = TypedPointerType::get(TPT->getElementType(),
+                                            ArgTy->getPointerAddressSpace());
     *ArgIter++ = DemangledTy;
   }
   return DemangledSuccessfully;