LLVM IR should allow bitcast between address spaces with the same size.

[skc7]

Summary

When the addrspacecast instruction was added, the ability to bitcast between pointers from different address spaces was removed.
There are cases, where after analysis, cast between pointers from different address spaces can be concluded to be a no-op cast.
If bitcast can be allowed in these scenarios, it would help further optimise the IR in Transform passes since its a no-op cast.
This enhancement to bitcast will require that pointers to the two address spaces have the same bit widths(can be queried from DataLayout).
Frontend should never misuse the bitcast wherever addrspace cast would have been more appropriate.

For example consider the below IR:

GVN pass has discovered a reinterpretation of bits via a store followed by a load.

%struct.S.coerce = type { i32 addrspace(1)* }
%s.sroa.0 = alloca i32*, align 8, addrspace(5)
%0 = extractvalue %struct.S.coerce %s.coerce, 0
%1 = bitcast i32* addrspace(5)* %s.sroa.0 to i32 addrspace(1)* addrspace(5)*
%2 = addrspacecast i32 addrspace(1)* addrspace(5)* %1 to i32 addrspace(1)
store i32 addrspace(1)* %0, i32 addrspace(1) %2, align 8

%3 = load i32*, i32* addrspace(5)* %s.sroa.0, align 8, !tbaa !2

GVN pass currently introduces no-op ptrotoint/inttoptr for load.
%3 = ptrtoint i32 addrspace(1)* %0 to i64
%4 = inttoptr i64 %3 to i32*

If bitcast of pointers from different address is allowed, load can be replaced with no-op bitcast
%3 = bitcast i32 addrspace(1)* %0 to i32*

[lebedev.ri]

Is there an RFC? This quite seems like asking for problems.

[arsenm]

Patch description should include this avoids a need to introduce ptrtoint/inttoptr pairs

[lebedev.ri]

In D114533#3151423, @arsenm wrote:

Patch description should include this avoids a need to introduce ptrtoint/inttoptr pairs

That is a good point, but all the motivational cases seem to be about chaining the address space of the pointee pointer.
Does this come up for changing the address space of the pointer itself? I'm just wondering if this is still relevant with opaque pointers.

[arsenm]

In D114533#3151482, @lebedev.ri wrote:

In D114533#3151423, @arsenm wrote:

Patch description should include this avoids a need to introduce ptrtoint/inttoptr pairs

That is a good point, but all the motivational cases seem to be about chaining the address space of the pointee pointer.
Does this come up for changing the address space of the pointer itself? I'm just wondering if this is still relevant with opaque pointers.

Nothing about address spaces changes with opaque pointers. The address space is a property of the pointer itself, not the memory it points to. This is for dealing with cases where we end up with a bit reinterpret of a pointer in another address space, and need to do a true no-op cast to convert them.

[jrtc27]

This seems like it should not apply to non-integral address spaces?

llvm/docs/LangRef.rst

11026

This should be illegal, not legal and undefined, you really want the IR verifier to be able to pick up on this at least, if not an assertion at creation time

llvm/include/llvm/IR/InstrTypes.h

729

Typo "e"

[arsenm]

In D114533#3153924, @jrtc27 wrote:

This seems like it should not apply to non-integral address spaces?

No, it shouldn’t care about the individual address spaces. It’s a reinterpret of the bits, the type meanings don’t matter

[jrtc27]

In D114533#3154225, @arsenm wrote:

In D114533#3153924, @jrtc27 wrote:

This seems like it should not apply to non-integral address spaces?

No, it shouldn’t care about the individual address spaces. It’s a reinterpret of the bits, the type meanings don’t matter

Well, they absolutely do for us downstream, but we also don't use the non-integral address space feature, since it didn't exist when our fork started and also has overly restrictive semantics. Normally the places we need to stop these kinds of casts/reinterpretations are a subset of those for non-integral address spaces, but maybe this is one of those exceptions then. I certainly have no clue about what the non-integral address spaces are actually used for and mean :)

[skc7]

Updated diff with changes suggested by jrtc27

[loladiro]

@jrtc27 is correct. This absolutely must not apply to non-integral address spaces. It is not legal for LLVM to introduce additional ptrtoint instructions for non-integral address spaces that were not present in the original input IR. That doesn't change if the spelling of a ptrtoint/inttoptr pair is changed to bitcast. There is a bit of a larger issue here that LLVM IR isn't really rich enough to currently describe what operations are legal for the optimizer to introduce and what aren't. Every frontend/backend that uses them has their own rules that appear obvious for a particular use case, but aren't necessarily general. A similar issue applies to commuting GEPs with addrspacecasts. I'm wondering if we need something like the datalayout but for describing relationships between addrspaces and what things are legal and what are not.

[skc7]

updated test IR files.

[skc7]

Rebase

clang/lib/CodeGen/CGAtomic.cpp

if (getEvaluationKind() == TEK_Scalar &&
         !hasPadding()) ||
        !AsValue)) {
     auto *ValTy = AsValue
                       ? CGF.ConvertTypeForMem(ValueTy)
                       : getAtomicAddress().getElementType();
     if (ValTy->isIntegerTy()) {
       assert(IntVal->getType() == ValTy && "Different integer types.");
       return RValue::get(CGF.EmitFromMemory(IntVal, ValueTy));
-    } else if (ValTy->isPointerTy())
+    } else if (ValTy->isPointerTy()) {
       return RValue::get(CGF.Builder.CreateIntToPtr(IntVal, ValTy));
-    else if (llvm::CastInst::isBitCastable(IntVal->getType(), ValTy))
+    } else if (llvm::CastInst::isBitCastable(IntVal->getType(), ValTy,
+                                             CGF.CGM.getDataLayout())) {
       return RValue::get(CGF.Builder.CreateBitCast(IntVal, ValTy));
     }
+  }
 
   // Create a temporary.  This needs to be big enough to hold the
   // atomic integer.
   Address Temp = Address::invalid();
   bool TempIsVolatile = false;
   if (AsValue && getEvaluationKind() == TEK_Aggregate) {
     assert(!ResultSlot.isIgnored());
     Temp = ResultSlot.getAddress();
if (RVal.isScalar() && (!hasPadding() || !LVal.isSimple())) {
     if (isa<llvm::IntegerType>(Value->getType()))
       return CGF.EmitToMemory(Value, ValueTy);
     else {
       llvm::IntegerType *InputIntTy = llvm::IntegerType::get(
           CGF.getLLVMContext(),
           LVal.isSimple() ? getValueSizeInBits() : getAtomicSizeInBits());
       if (isa<llvm::PointerType>(Value->getType()))
         return CGF.Builder.CreatePtrToInt(Value, InputIntTy);
-      else if (llvm::BitCastInst::isBitCastable(Value->getType(), InputIntTy))
+      else if (llvm::BitCastInst::isBitCastable(Value->getType(), InputIntTy,
+                                                CGF.CGM.getDataLayout()))
         return CGF.Builder.CreateBitCast(Value, InputIntTy);
     }
   }
   // Otherwise, we need to go through memory.
   // Put the r-value in memory.
   Address Addr = materializeRValue(RVal);
 
   // Cast the temporary to the atomic int type and pull a value out.

llvm/docs/LangRef.rst

 
 Semantics:
 """"""""""
 
 The '``bitcast``' instruction converts ``value`` to type ``ty2``. It
 is always a *no-op cast* because no bits change with this
 conversion. The conversion is done as if the ``value`` had been stored
 to memory and read back as type ``ty2``. Pointer (or vector of
-pointers) types may only be converted to other pointer (or vector of
-pointers) types with the same address space through this instruction.
+pointers) types can be converted to other pointer (or vector of
+pointers) types in the same address space or different address spaces 
+with this instruction. When such a reinterpretation 
+of bits is not supported by the target, value is poison. 
+(Note: Frontends are expected to check validity but optimisations
+may infer such a poison bitcast from the input program).
 To convert pointers to other types, use the :ref:`inttoptr <i_inttoptr>`
 or :ref:`ptrtoint <i_ptrtoint>` instructions first.
 
 There is a caveat for bitcasts involving vector types in relation to
 endianess. For example ``bitcast <2 x i8> <value> to i16`` puts element zero
 of the vector in the least significant bits of the i16 for little-endian while
 element zero ends up in the most significant bits for big-endian.
 
 Example:
 """"""""
 
 .. code-block:: text
 
       %X = bitcast i8 255 to i8          ; yields i8 :-1
       %Y = bitcast i32* %x to i16*      ; yields i16*:%x
       %Z = bitcast <2 x i32> %V to i64;  ; yields i64: %V (depends on endianess)
       %Z = bitcast <2 x i32*> %V to <2 x i64*> ; yields <2 x i64*>
+      %W = bitcast i32* %x to i32 addrspace(1)*    ; yields i32 addrspace(1)*:%w
 
 .. _i_addrspacecast:
 
 '``addrspacecast .. to``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""

llvm/include/llvm/Analysis/InstSimplifyFolder.h

public:
   //===--------------------------------------------------------------------===//
 
   Value *CreateCast(Instruction::CastOps Op, Constant *C,
                     Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return ConstFolder.CreateCast(Op, C, DestTy);
   }
+  Value *CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy,
+                    const DataLayout &DL) const override {
+    if (C->getType() == DestTy)
+      return C; // avoid calling Fold
+    return ConstFolder.CreateCast(Op, C, DestTy, DL);
+  }
   Value *CreateIntCast(Constant *C, Type *DestTy,
                        bool isSigned) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return ConstFolder.CreateIntCast(C, DestTy, isSigned);
   }
   Value *CreatePointerCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return ConstFolder.CreatePointerCast(C, DestTy);
   }
   Value *CreateFPCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return ConstFolder.CreateFPCast(C, DestTy);
   }
   Value *CreateBitCast(Constant *C, Type *DestTy) const override {
     return ConstFolder.CreateBitCast(C, DestTy);
   }
+  Value *CreateBitCast(Constant *C, Type *DestTy,
+                       const DataLayout &DL) const override {
+    return ConstFolder.CreateBitCast(C, DestTy, DL);
+  }
   Value *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return ConstFolder.CreateIntToPtr(C, DestTy);
   }
   Value *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return ConstFolder.CreatePtrToInt(C, DestTy);
   }
   Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)

llvm/include/llvm/Analysis/TargetFolder.h

public:
   //===--------------------------------------------------------------------===//
 
   Constant *CreateCast(Instruction::CastOps Op, Constant *C,
                        Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getCast(Op, C, DestTy));
   }
+  Constant *CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy,
+                       const DataLayout &DL) const override {
+    if (C->getType() == DestTy)
+      return C; // avoid calling Fold
+    return Fold(ConstantExpr::getCast(Op, C, DestTy, DL));
+  }
   Constant *CreateIntCast(Constant *C, Type *DestTy,
                           bool isSigned) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getIntegerCast(C, DestTy, isSigned));
   }
   Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getPointerCast(C, DestTy));
   }
   Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)
       return C; // avoid calling Fold
     return Fold(ConstantExpr::getFPCast(C, DestTy));
   }
   Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
+  Constant *CreateBitCast(Constant *C, Type *DestTy,
+                          const DataLayout &DL) const override {
+    return CreateCast(Instruction::BitCast, C, DestTy, DL);
+  }
   Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
   Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
   Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override {
     if (C->getType() == DestTy)

llvm/include/llvm/IR/ConstantFolder.h

public:
   // Cast/Conversion Operators
   //===--------------------------------------------------------------------===//
 
   Constant *CreateCast(Instruction::CastOps Op, Constant *C,
                        Type *DestTy) const override {
     return ConstantExpr::getCast(Op, C, DestTy);
   }
 
+  Constant *CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy,
+                       const DataLayout &DL) const override {
+    return ConstantExpr::getCast(Op, C, DestTy, DL);
+  }
+
   Constant *CreatePointerCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getPointerCast(C, DestTy);
   }
 
   Constant *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
                                                 Type *DestTy) const override {
     return ConstantExpr::getPointerBitCastOrAddrSpaceCast(C, DestTy);
   }
 
   Constant *CreateIntCast(Constant *C, Type *DestTy,
                           bool isSigned) const override {
     return ConstantExpr::getIntegerCast(C, DestTy, isSigned);
   }
 
   Constant *CreateFPCast(Constant *C, Type *DestTy) const override {
     return ConstantExpr::getFPCast(C, DestTy);
   }
 
   Constant *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
 
+  Constant *CreateBitCast(Constant *C, Type *DestTy,
+                          const DataLayout &DL) const override {
+    return CreateCast(Instruction::BitCast, C, DestTy, DL);
+  }
+
   Constant *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
 
   Constant *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
 

llvm/include/llvm/IR/Constants.h

public:
   static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
   static Constant *getPtrToInt(Constant *C, Type *Ty,
                                bool OnlyIfReduced = false);
   static Constant *getIntToPtr(Constant *C, Type *Ty,
                                bool OnlyIfReduced = false);
   static Constant *getBitCast(Constant *C, Type *Ty,
                               bool OnlyIfReduced = false);
+  static Constant *getBitCast(Constant *C, Type *Ty, const DataLayout &DL,
+                              bool OnlyIfReduced = false);
   static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
                                     bool OnlyIfReduced = false);
 
   static Constant *getNSWNeg(Constant *C) { return getNeg(C, false, true); }
   static Constant *getNUWNeg(Constant *C) { return getNeg(C, true, false); }
 
   static Constant *getNSWAdd(Constant *C1, Constant *C2) {
     return getAdd(C1, C2, false, true);
public:
   ///
   /// \param ops The opcode for the conversion
   /// \param C  The constant to be converted
   /// \param Ty The type to which the constant is converted
   /// \param OnlyIfReduced see \a getWithOperands() docs.
   static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
                            bool OnlyIfReduced = false);
 
+  /// Convenience function for getting a Cast operation.
+  ///
+  /// \param ops The opcode for the conversion
+  /// \param C  The constant to be converted
+  /// \param Ty The type to which the constant is converted
+  /// \param DL The DataLayout
+  /// \param OnlyIfReduced see \a getWithOperands() docs.
+  static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
+                           const DataLayout &DL, bool OnlyIfReduced = false);
+
   // Create a ZExt or BitCast cast constant expression
   static Constant *
   getZExtOrBitCast(Constant *C, ///< The constant to zext or bitcast
                    Type *Ty     ///< The type to zext or bitcast C to
   );
 
   // Create a SExt or BitCast cast constant expression
   static Constant *

llvm/include/llvm/IR/IRBuilder.h

Value *CreateIntToPtr(Value *V, Type *DestTy,
     return CreateCast(Instruction::IntToPtr, V, DestTy, Name);
   }
 
   Value *CreateBitCast(Value *V, Type *DestTy,
                        const Twine &Name = "") {
     return CreateCast(Instruction::BitCast, V, DestTy, Name);
   }
 
+  Value *CreateBitCast(Value *V, Type *DestTy, const DataLayout &DL,
+                       const Twine &Name = "") {
+    return CreateCast(Instruction::BitCast, V, DestTy, DL, Name);
+  }
+
   Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
                              const Twine &Name = "") {
     return CreateCast(Instruction::AddrSpaceCast, V, DestTy, Name);
   }
 
   Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
                              const Twine &Name = "") {
     if (V->getType() == DestTy)
Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
                     const Twine &Name = "") {
     if (V->getType() == DestTy)
       return V;
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreateCast(Op, VC, DestTy), Name);
     return Insert(CastInst::Create(Op, V, DestTy), Name);
   }
 
+  Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
+                    const DataLayout &DL, const Twine &Name = "") {
+    if (V->getType() == DestTy)
+      return V;
+    if (auto *VC = dyn_cast<Constant>(V))
+      return Insert(Folder.CreateCast(Op, VC, DestTy, DL), Name);
+    return Insert(CastInst::Create(Op, V, DestTy, DL), Name);
+  }
+
   Value *CreatePointerCast(Value *V, Type *DestTy,
                            const Twine &Name = "") {
     if (V->getType() == DestTy)
       return V;
     if (auto *VC = dyn_cast<Constant>(V))
       return Insert(Folder.CreatePointerCast(VC, DestTy), Name);
     return Insert(CastInst::CreatePointerCast(V, DestTy), Name);
   }

llvm/include/llvm/IR/IRBuilderFolder.h

public:
   virtual Value *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const = 0;
 
   //===--------------------------------------------------------------------===//
   // Cast/Conversion Operators
   //===--------------------------------------------------------------------===//
 
   virtual Value *CreateCast(Instruction::CastOps Op, Constant *C,
                             Type *DestTy) const = 0;
+  virtual Value *CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy,
+                            const DataLayout &DL) const = 0;
   virtual Value *CreatePointerCast(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreatePointerBitCastOrAddrSpaceCast(Constant *C,
                                                      Type *DestTy) const = 0;
   virtual Value *CreateIntCast(Constant *C, Type *DestTy,
                                bool isSigned) const = 0;
   virtual Value *CreateFPCast(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreateBitCast(Constant *C, Type *DestTy) const = 0;
+  virtual Value *CreateBitCast(Constant *C, Type *DestTy,
+                               const DataLayout &DL) const = 0;
   virtual Value *CreateIntToPtr(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreatePtrToInt(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const = 0;
   virtual Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const = 0;
 
   //===--------------------------------------------------------------------===//
   // Compare Instructions

llvm/include/llvm/IR/InstrTypes.h

 #include "llvm/ADT/Sequence.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/CallingConv.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/OperandTraits.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
public:
   static CastInst *Create(
     Instruction::CastOps,    ///< The opcode for the cast instruction
     Value *S,                ///< The value to be casted (operand 0)
     Type *Ty,          ///< The type to which operand is casted
     const Twine &Name, ///< The name for the instruction
     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
   );
 
+  /// Provides a way to construct any of the CastInst subclasses using an
+  /// opcode instead of the subclass's constructor. The opcode must be in the
+  /// CastOps category (Instruction::isCast(opcode) returns true). DataLayout
+  /// is used to check validity of bitcast. This constructor has
+  /// insert-before-instruction semantics to automatically
+  /// insert the new CastInst before InsertBefore (if it is non-null).
+  /// Construct any of the CastInst subclasses
+  static CastInst *Create(
+      Instruction::CastOps,   ///< The opcode of the cast instruction
+      Value *S,               ///< The value to be casted (operand 0)
+      Type *Ty,               ///< The type to which cast should be made
+      const DataLayout &DL,   ///< DataLayout to check validity of bitcast
+      const Twine &Name = "", ///< Name for the instruction
+      Instruction *InsertBefore = nullptr ///< Place to insert the instruction
+  );
+  /// Provides a way to construct any of the CastInst subclasses using an
+  /// opcode instead of the subclass's constructor. The opcode must be in the
+  /// CastOps category. DataLayout is used to check validity of bitcast.
+  /// This constructor has insert-at-end-of-block semantics
+  /// to automatically insert the new CastInst at the end of InsertAtEnd (if
+  /// its non-null).
+  /// Construct any of the CastInst subclasses
+  static CastInst *
+  Create(Instruction::CastOps,   ///< The opcode for the cast instruction
+         Value *S,               ///< The value to be casted (operand 0)
+         Type *Ty,               ///< The type to which operand is casted
+         const DataLayout &DL,   ///< DataLayout to check validity of bitcast
+         const Twine &Name,      ///< The name for the instruction
+         BasicBlock *InsertAtEnd ///< The block to insert the instruction into
+  );
+
   /// Create a ZExt or BitCast cast instruction
   static CastInst *CreateZExtOrBitCast(
     Value *S,                ///< The value to be casted (operand 0)
     Type *Ty,          ///< The type to which cast should be made
     const Twine &Name = "", ///< Name for the instruction
     Instruction *InsertBefore = nullptr ///< Place to insert the instruction
   );
 
static CastInst *CreateTruncOrBitCast(
     Value *S,                ///< The value to be casted (operand 0)
     Type *Ty,          ///< The type to which operand is casted
     const Twine &Name, ///< The name for the instruction
     BasicBlock *InsertAtEnd  ///< The block to insert the instruction into
   );
 
   /// Check whether a bitcast between these types is valid
   static bool isBitCastable(
-    Type *SrcTy, ///< The Type from which the value should be cast.
-    Type *DestTy ///< The Type to which the value should be cast.
+      Type *SrcTy,         ///< The Type from which the value should be cast.
+      Type *DestTy,        ///< The Type to which the value should be cast.
+      const DataLayout &DL ///< The DataLayout to check validity of bitcast
   );
 
   /// Check whether a bitcast, inttoptr, or ptrtoint cast between these
   /// types is valid and a no-op.
   ///
   /// This ensures that any pointer<->integer cast has enough bits in the
   /// integer and any other cast is a bitcast.
   static bool isBitOrNoopPointerCastable(
public:
   /// Opcode op is valid or not.
   /// @returns true iff the proposed cast is valid.
   /// Determine if a cast is valid without creating one.
   static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy);
   static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
     return castIsValid(op, S->getType(), DstTy);
   }
 
+  /// This method can be used to determine if a cast from SrcTy to DstTy using
+  /// Opcode op and DataLayout DL is valid or not
+  /// @returns true iff the proposed cast is valid.
+  /// Determine if a cast is valid without creating one.
+  static bool castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy,
+                          const DataLayout &DL);
+  static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy,
+                          const DataLayout &DL) {
+    return castIsValid(op, S->getType(), DstTy, DL);
+  }
+
   /// Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->isCast();
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

llvm/include/llvm/IR/Instructions.h

public:
   /// Constructor with insert-at-end-of-block semantics
   BitCastInst(
     Value *S,                     ///< The value to be casted
     Type *Ty,                     ///< The type to casted to
     const Twine &NameStr,         ///< A name for the new instruction
     BasicBlock *InsertAtEnd       ///< The block to insert the instruction into
   );
 
+  /// Constructor with DataLayout and insert-before-instruction semantics
+  BitCastInst(
+      Value *S,             ///< The value to be casted
+      Type *Ty,             ///< The type to casted to
+      const DataLayout &DL, ///< The DataLayout to check validity of bitcast
+      const Twine &NameStr = "", ///< A name for the new instruction
+      Instruction *InsertBefore =
+          nullptr ///< Where to insert the new instruction
+  );
+
+  /// Constructor with DataLayout and insert-at-end-of-block semantics
+  BitCastInst(
+      Value *S,               ///< The value to be casted
+      Type *Ty,               ///< The type to casted to
+      const DataLayout &DL,   ///< The DataLayout to check validity of bitcast
+      const Twine &NameStr,   ///< A name for the new instruction
+      BasicBlock *InsertAtEnd ///< The block to insert the instruction into
+  );
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == BitCast;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 };

llvm/include/llvm/IR/NoFolder.h

public:
   // Cast/Conversion Operators
   //===--------------------------------------------------------------------===//
 
   Instruction *CreateCast(Instruction::CastOps Op, Constant *C,
                           Type *DestTy) const override {
     return CastInst::Create(Op, C, DestTy);
   }
 
+  Instruction *CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy,
+                          const DataLayout &DL) const override {
+    return CastInst::Create(Op, C, DestTy, DL);
+  }
+
   Instruction *CreatePointerCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreatePointerCast(C, DestTy);
   }
 
   Instruction *CreatePointerBitCastOrAddrSpaceCast(
       Constant *C, Type *DestTy) const override {
     return CastInst::CreatePointerBitCastOrAddrSpaceCast(C, DestTy);
   }
 
   Instruction *CreateIntCast(Constant *C, Type *DestTy,
                              bool isSigned) const override {
     return CastInst::CreateIntegerCast(C, DestTy, isSigned);
   }
 
   Instruction *CreateFPCast(Constant *C, Type *DestTy) const override {
     return CastInst::CreateFPCast(C, DestTy);
   }
 
   Instruction *CreateBitCast(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::BitCast, C, DestTy);
   }
 
+  Instruction *CreateBitCast(Constant *C, Type *DestTy,
+                             const DataLayout &DL) const override {
+    return CreateCast(Instruction::BitCast, C, DestTy, DL);
+  }
+
   Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::IntToPtr, C, DestTy);
   }
 
   Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const override {
     return CreateCast(Instruction::PtrToInt, C, DestTy);
   }
 

llvm/lib/Analysis/ConstantFolding.cpp

static Constant *foldConstVectorToAPInt(APInt &Result, Type *DestTy,
 
   return nullptr;
 }
 
 /// Constant fold bitcast, symbolically evaluating it with DataLayout.
 /// This always returns a non-null constant, but it may be a
 /// ConstantExpr if unfoldable.
 Constant *FoldBitCast(Constant *C, Type *DestTy, const DataLayout &DL) {
-  assert(CastInst::castIsValid(Instruction::BitCast, C, DestTy) &&
-         "Invalid constantexpr bitcast!");
+  assert(
+      CastInst::castIsValid(Instruction::BitCast, C->getType(), DestTy, DL) &&
 
   // Catch the obvious splat cases.
   if (Constant *Res = ConstantFoldLoadFromUniformValue(C, DestTy))
     return Res;
 
   if (auto *VTy = dyn_cast<VectorType>(C->getType())) {
     // Handle a vector->scalar integer/fp cast.
     if (isa<IntegerType>(DestTy) || DestTy->isFloatingPointTy()) {
if (SrcSize == DestSize &&
       Instruction::CastOps Cast = Instruction::BitCast;
       // If we are going from a pointer to int or vice versa, we spell the cast
       // differently.
       if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
         Cast = Instruction::IntToPtr;
       else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
         Cast = Instruction::PtrToInt;
 
-      if (CastInst::castIsValid(Cast, C, DestTy))
+      if (CastInst::castIsValid(Cast, C, DestTy, DL))
         return ConstantExpr::getCast(Cast, C, DestTy);
     }
 
     // If this isn't an aggregate type, there is nothing we can do to drill down
     // and find a bitcastable constant.
     if (!SrcTy->isAggregateType() && !SrcTy->isVectorTy())
       return nullptr;
 

llvm/lib/Analysis/LoopUnrollAnalyzer.cpp

 bool UnrolledInstAnalyzer::visitCastInst(CastInst &I) {
   Value *Op = I.getOperand(0);
   if (Value *Simplified = SimplifiedValues.lookup(Op))
     Op = Simplified;
 
   // The cast can be invalid, because SimplifiedValues contains results of SCEV
   // analysis, which operates on integers (and, e.g., might convert i8* null to
   // i32 0).
-  if (CastInst::castIsValid(I.getOpcode(), Op, I.getType())) {
-    const DataLayout &DL = I.getModule()->getDataLayout();
+  if (CastInst::castIsValid(I.getOpcode(), Op->getType(), I.getType(), DL)) {
     if (Value *V = SimplifyCastInst(I.getOpcode(), Op, I.getType(), DL)) {
       SimplifiedValues[&I] = V;
       return true;
     }
   }
 
   return Base::visitCastInst(I);
 }

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseCast(Instruction *&Inst, PerFunctionState &PFS,
   LocTy Loc;
   Value *Op;
   Type *DestTy = nullptr;
   if (parseTypeAndValue(Op, Loc, PFS) ||
       parseToken(lltok::kw_to, "expected 'to' after cast value") ||
       parseType(DestTy))
     return true;
 
-  if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy)) {
-    CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy);
+  if (!CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy,
+                             M->getDataLayout())) {
+    CastInst::castIsValid((Instruction::CastOps)Opc, Op, DestTy,
+                          M->getDataLayout());
     return error(Loc, "invalid cast opcode for cast from '" +
                           getTypeString(Op->getType()) + "' to '" +
                           getTypeString(DestTy) + "'");
   }
-  Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy);
+  Inst = CastInst::Create((Instruction::CastOps)Opc, Op, DestTy,
+                          M->getDataLayout());
   return false;
 }
 
 /// parseSelect
 ///   ::= 'select' TypeAndValue ',' TypeAndValue ',' TypeAndValue
 bool LLParser::parseSelect(Instruction *&Inst, PerFunctionState &PFS) {
   LocTy Loc;
   Value *Op0, *Op1, *Op2;

llvm/lib/IR/AutoUpgrade.cpp

for (User *U : make_early_inc_range(Fn->users())) {
       IRBuilder<> Builder(CI->getParent(), CI->getIterator());
       FunctionType *NewFuncTy = NewFn->getFunctionType();
       SmallVector<Value *, 2> Args;
 
       // Don't upgrade the intrinsic if it's not valid to bitcast the return
       // value to the return type of the old function.
       if (NewFuncTy->getReturnType() != CI->getType() &&
           !CastInst::castIsValid(Instruction::BitCast, CI,
-                                 NewFuncTy->getReturnType()))
+                                 NewFuncTy->getReturnType(), M.getDataLayout()))
         continue;
 
       bool InvalidCast = false;
 
       for (unsigned I = 0, E = CI->arg_size(); I != E; ++I) {
         Value *Arg = CI->getArgOperand(I);
 
         // Bitcast argument to the parameter type of the new function if it's
         // not a variadic argument.
         if (I < NewFuncTy->getNumParams()) {
           // Don't upgrade the intrinsic if it's not valid to bitcast the argument
           // to the parameter type of the new function.
           if (!CastInst::castIsValid(Instruction::BitCast, Arg,
-                                     NewFuncTy->getParamType(I))) {
+                                     NewFuncTy->getParamType(I),
+                                     M.getDataLayout())) {
             InvalidCast = true;
             break;
           }
           Arg = Builder.CreateBitCast(Arg, NewFuncTy->getParamType(I));
         }
         Args.push_back(Arg);
       }
 

llvm/lib/IR/Constants.cpp

case Instruction::IntToPtr:
     return getIntToPtr(C, Ty, OnlyIfReduced);
   case Instruction::BitCast:
     return getBitCast(C, Ty, OnlyIfReduced);
   case Instruction::AddrSpaceCast:
     return getAddrSpaceCast(C, Ty, OnlyIfReduced);
   }
 }
 
+Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
+                                const DataLayout &DL, bool OnlyIfReduced) {
+  Instruction::CastOps opc = Instruction::CastOps(oc);
+  assert(Instruction::isCast(opc) && "opcode out of range");
+  assert(C && Ty && "Null arguments to getCast");
+  assert(CastInst::castIsValid(opc, C->getType(), Ty, DL) &&
+         "Invalid constantexpr cast!");
+
+  switch (opc) {
+  default:
+    llvm_unreachable("Invalid cast opcode");
+  case Instruction::Trunc:
+    return getTrunc(C, Ty, OnlyIfReduced);
+  case Instruction::ZExt:
+    return getZExt(C, Ty, OnlyIfReduced);
+  case Instruction::SExt:
+    return getSExt(C, Ty, OnlyIfReduced);
+  case Instruction::FPTrunc:
+    return getFPTrunc(C, Ty, OnlyIfReduced);
+  case Instruction::FPExt:
+    return getFPExtend(C, Ty, OnlyIfReduced);
+  case Instruction::UIToFP:
+    return getUIToFP(C, Ty, OnlyIfReduced);
+  case Instruction::SIToFP:
+    return getSIToFP(C, Ty, OnlyIfReduced);
+  case Instruction::FPToUI:
+    return getFPToUI(C, Ty, OnlyIfReduced);
+  case Instruction::FPToSI:
+    return getFPToSI(C, Ty, OnlyIfReduced);
+  case Instruction::PtrToInt:
+    return getPtrToInt(C, Ty, OnlyIfReduced);
+  case Instruction::IntToPtr:
+    return getIntToPtr(C, Ty, OnlyIfReduced);
+  case Instruction::BitCast:
+    return getBitCast(C, Ty, DL, OnlyIfReduced);
+  case Instruction::AddrSpaceCast:
+    return getAddrSpaceCast(C, Ty, OnlyIfReduced);
+  }
+}
+
 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return getBitCast(C, Ty);
   return getZExt(C, Ty);
 }
 
 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
   if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy,
 
   // It is common to ask for a bitcast of a value to its own type, handle this
   // speedily.
   if (C->getType() == DstTy) return C;
 
   return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
 }
 
+Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy,
+                                   const DataLayout &DL, bool OnlyIfReduced) {
+  assert(CastInst::castIsValid(Instruction::BitCast, C->getType(), DstTy, DL) &&
+         "Invalid constantexpr bitcast!");
+
+  // It is common to ask for a bitcast of a value to its own type, handle this
+  // speedily.
+  if (C->getType() == DstTy)
+    return C;
+
+  return getFoldedCast(Instruction::BitCast, C, DstTy, OnlyIfReduced);
+}
+
 Constant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy,
                                          bool OnlyIfReduced) {
   assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) &&
          "Invalid constantexpr addrspacecast!");
 
   // Canonicalize addrspacecasts between different pointer types by first
   // bitcasting the pointer type and then converting the address space.
   PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());

llvm/lib/IR/Instructions.cpp

 /// # bitcast i32* %x to i8*
 /// # bitcast <2 x i32> %x to <4 x i16>
 /// # ptrtoint i32* %x to i32     ; on 32-bit plaforms only
 /// Determine if the described cast is a no-op.
 bool CastInst::isNoopCast(Instruction::CastOps Opcode,
                           Type *SrcTy,
                           Type *DestTy,
                           const DataLayout &DL) {
-  assert(castIsValid(Opcode, SrcTy, DestTy) && "method precondition");
+  assert(castIsValid(Opcode, SrcTy, DestTy, DL) && "method precondition");
   switch (Opcode) {
     default: llvm_unreachable("Invalid CastOp");
     case Instruction::Trunc:
     case Instruction::ZExt:
     case Instruction::SExt:
     case Instruction::FPTrunc:
     case Instruction::FPExt:
     case Instruction::UIToFP:
CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
   case PtrToInt:      return new PtrToIntInst      (S, Ty, Name, InsertAtEnd);
   case IntToPtr:      return new IntToPtrInst      (S, Ty, Name, InsertAtEnd);
   case BitCast:       return new BitCastInst       (S, Ty, Name, InsertAtEnd);
   case AddrSpaceCast: return new AddrSpaceCastInst (S, Ty, Name, InsertAtEnd);
   default: llvm_unreachable("Invalid opcode provided");
   }
 }
 
+CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
+                           const DataLayout &DL, const Twine &Name,
+                           Instruction *InsertBefore) {
+  assert(castIsValid(op, S, Ty, DL) && "Invalid cast!");
+
+  // Construct and return the appropriate CastInst subclass
+  switch (op) {
+  case BitCast:
+    return new BitCastInst(S, Ty, DL, Name, InsertBefore);
+  default:
+    CastInst::Create(op, S, Ty, Name, InsertBefore);
+  }
+}
+
+CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
+                           const DataLayout &DL, const Twine &Name,
+                           BasicBlock *InsertAtEnd) {
+  assert(castIsValid(op, S, Ty, DL) && "Invalid cast!");
+
+  // Construct and return the appropriate CastInst subclass
+  switch (op) {
+  case BitCast:
+    return new BitCastInst(S, Ty, DL, Name, InsertAtEnd);
+  default:
+    CastInst::Create(op, S, Ty, Name, InsertAtEnd);
+  }
+}
+
 CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
                                         const Twine &Name,
                                         Instruction *InsertBefore) {
   if (S->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits())
     return Create(Instruction::BitCast, S, Ty, Name, InsertBefore);
   return Create(Instruction::ZExt, S, Ty, Name, InsertBefore);
 }
 
CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
   unsigned SrcBits = C->getType()->getScalarSizeInBits();
   unsigned DstBits = Ty->getScalarSizeInBits();
   Instruction::CastOps opcode =
     (SrcBits == DstBits ? Instruction::BitCast :
      (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt));
   return Create(opcode, C, Ty, Name, InsertAtEnd);
 }
 
-bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
+bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy, const DataLayout &DL) {
   if (!SrcTy->isFirstClassType() || !DestTy->isFirstClassType())
     return false;
 
   if (SrcTy == DestTy)
     return true;
 
   if (VectorType *SrcVecTy = dyn_cast<VectorType>(SrcTy)) {
     if (VectorType *DestVecTy = dyn_cast<VectorType>(DestTy)) {
       if (SrcVecTy->getElementCount() == DestVecTy->getElementCount()) {
         // An element by element cast. Valid if casting the elements is valid.
         SrcTy = SrcVecTy->getElementType();
         DestTy = DestVecTy->getElementType();
       }
     }
   }
 
   if (PointerType *DestPtrTy = dyn_cast<PointerType>(DestTy)) {
     if (PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy)) {
-      return SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace();
+      if (SrcPtrTy->getAddressSpace() == DestPtrTy->getAddressSpace()) {
+        return true;
+      } else {
+        return DL.getPointerTypeSizeInBits(SrcTy) ==
+               DL.getPointerTypeSizeInBits(DestTy);
+      }
     }
   }
 
   TypeSize SrcBits = SrcTy->getPrimitiveSizeInBits();   // 0 for ptr
   TypeSize DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr
 
   // Could still have vectors of pointers if the number of elements doesn't
   // match
if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
     if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
       return (IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy) &&
               !DL.isNonIntegralPointerType(PtrTy));
   if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
     if (auto *IntTy = dyn_cast<IntegerType>(SrcTy))
       return (IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy) &&
               !DL.isNonIntegralPointerType(PtrTy));
 
-  return isBitCastable(SrcTy, DestTy);
+  return isBitCastable(SrcTy, DestTy, DL);
 }
 
 // Provide a way to get a "cast" where the cast opcode is inferred from the
 // types and size of the operand. This, basically, is a parallel of the
 // logic in the castIsValid function below.  This axiom should hold:
 //   castIsValid( getCastOpcode(Val, Ty), Val, Ty)
 // should not assert in castIsValid. In other words, this produces a "correct"
 // casting opcode for the arguments passed to it.

 //===----------------------------------------------------------------------===//
 //                    CastInst SubClass Constructors
 //===----------------------------------------------------------------------===//
 
 /// Check that the construction parameters for a CastInst are correct. This
 /// could be broken out into the separate constructors but it is useful to have
 /// it in one place and to eliminate the redundant code for getting the sizes
 /// of the types involved.
-bool
-CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
+bool CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy) {
   if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() ||
       SrcTy->isAggregateType() || DstTy->isAggregateType())
     return false;
 
   // Get the size of the types in bits, and whether we are dealing
   // with vector types, we'll need this later.
   bool SrcIsVec = isa<VectorType>(SrcTy);
   bool DstIsVec = isa<VectorType>(DstTy);
case Instruction::AddrSpaceCast: {
     if (SrcPtrTy->getAddressSpace() == DstPtrTy->getAddressSpace())
       return false;
 
     return SrcEC == DstEC;
   }
   }
 }
 
+bool CastInst::castIsValid(Instruction::CastOps op, Type *SrcTy, Type *DstTy,
+                           const DataLayout &DL) {
+  if (!SrcTy->isFirstClassType() || !DstTy->isFirstClassType() ||
+      SrcTy->isAggregateType() || DstTy->isAggregateType())
+    return false;
+
+  // Get the size of the types in bits, and whether we are dealing
+  // with vector types, we'll need this later.
+  bool SrcIsVec = isa<VectorType>(SrcTy);
+  bool DstIsVec = isa<VectorType>(DstTy);
+
+  // If these are vector types, get the lengths of the vectors (using zero for
+  // scalar types means that checking that vector lengths match also checks that
+  // scalars are not being converted to vectors or vectors to scalars).
+  ElementCount SrcEC = SrcIsVec ? cast<VectorType>(SrcTy)->getElementCount()
+                                : ElementCount::getFixed(0);
+  ElementCount DstEC = DstIsVec ? cast<VectorType>(DstTy)->getElementCount()
+                                : ElementCount::getFixed(0);
+
+  switch (op) {
+  default:
+    return castIsValid(op, SrcTy, DstTy);
+  case Instruction::BitCast: {
+    PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
+    PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
+
+    // BitCast implies a no-op cast of type only. No bits change.
+    // However, you can't cast pointers to anything but pointers.
+    if (!SrcPtrTy != !DstPtrTy)
+      return false;
+
+    // For non-pointer cases, the cast is okay if the source and destination bit
+    // widths are identical.
+    if (!SrcPtrTy)
+      return SrcTy->getPrimitiveSizeInBits() == DstTy->getPrimitiveSizeInBits();
+
+    // If source or destionation is vector of pointers, compute the total bit
+    // width of vector elements. else if not vector, use the Pointer size from
+    // data layout.
+    unsigned SrcTypeSize =
+        SrcIsVec ? SrcEC.getKnownMinValue() * DL.getPointerTypeSizeInBits(SrcTy)
+                 : DL.getPointerTypeSizeInBits(SrcTy);
+    unsigned DstTypeSize =
+        DstIsVec ? DstEC.getKnownMinValue() * DL.getPointerTypeSizeInBits(DstTy)
+                 : DL.getPointerTypeSizeInBits(DstTy);
+
+    return SrcTypeSize == DstTypeSize;
+  }
+  }
+}
+
 TruncInst::TruncInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, Trunc, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal Trunc");
 }
 
 TruncInst::TruncInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd

 }
 
 BitCastInst::BitCastInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
 ) : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal BitCast");
 }
 
+BitCastInst::BitCastInst(Value *S, Type *Ty, const DataLayout &DL,
+                         const Twine &Name, Instruction *InsertBefore)
+    : CastInst(Ty, BitCast, S, Name, InsertBefore) {
+  assert(castIsValid(getOpcode(), S->getType(), Ty, DL) && "Illegal BitCast");
+}
+
+BitCastInst::BitCastInst(Value *S, Type *Ty, const DataLayout &DL,
+                         const Twine &Name, BasicBlock *InsertAtEnd)
+    : CastInst(Ty, BitCast, S, Name, InsertAtEnd) {
+  assert(castIsValid(getOpcode(), S->getType(), Ty, DL) && "Illegal BitCast");
+}
+
 AddrSpaceCastInst::AddrSpaceCastInst(
   Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
 ) : CastInst(Ty, AddrSpaceCast, S, Name, InsertBefore) {
   assert(castIsValid(getOpcode(), S, Ty) && "Illegal AddrSpaceCast");
 }
 
 AddrSpaceCastInst::AddrSpaceCastInst(
   Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd

llvm/lib/IR/Verifier.cpp

for (const Use &U : C->operands()) {
       Stack.push_back(OpC);
     }
   }
 }
 
 void Verifier::visitConstantExpr(const ConstantExpr *CE) {
   if (CE->getOpcode() == Instruction::BitCast)
     Assert(CastInst::castIsValid(Instruction::BitCast, CE->getOperand(0),
-                                 CE->getType()),
+                                 CE->getType(), DL),
            "Invalid bitcast", CE);
 }
 
 bool Verifier::verifyAttributeCount(AttributeList Attrs, unsigned Params) {
   // There shouldn't be more attribute sets than there are parameters plus the
   // function and return value.
   return Attrs.getNumAttrSets() <= Params + 2;
 }
if (SrcTy->isVectorTy()) {
     auto *VDest = cast<VectorType>(DestTy);
     Assert(VSrc->getElementCount() == VDest->getElementCount(),
            "IntToPtr Vector width mismatch", &I);
   }
   visitInstruction(I);
 }
 
 void Verifier::visitBitCastInst(BitCastInst &I) {
-  Assert(
-      CastInst::castIsValid(Instruction::BitCast, I.getOperand(0), I.getType()),
+  Assert(CastInst::castIsValid(Instruction::BitCast, I.getOperand(0),
+                               I.getType(), DL),
          "Invalid bitcast", &I);
   visitInstruction(I);
 }
 
 void Verifier::visitAddrSpaceCastInst(AddrSpaceCastInst &I) {
   Type *SrcTy = I.getOperand(0)->getType();
   Type *DestTy = I.getType();
 
   Assert(SrcTy->isPtrOrPtrVectorTy(), "AddrSpaceCast source must be a pointer",

llvm/lib/Transforms/Coroutines/Coroutines.cpp

#endif
       auto SI = Suspend->value_begin(), SE = Suspend->value_end();
       auto RI = ResultTys.begin(), RE = ResultTys.end();
       for (; SI != SE && RI != RE; ++SI, ++RI) {
         auto SrcTy = (*SI)->getType();
         if (SrcTy != *RI) {
           // The optimizer likes to eliminate bitcasts leading into variadic
           // calls, but that messes with our invariants.  Re-insert the
           // bitcast and ignore this type mismatch.
-          if (CastInst::isBitCastable(SrcTy, *RI)) {
+          if (CastInst::isBitCastable(SrcTy, *RI,
+                                      F.getParent()->getDataLayout())) {
             auto BCI = new BitCastInst(*SI, *RI, "", Suspend);
             SI->set(BCI);
             continue;
           }
 
 #ifndef NDEBUG
           Suspend->dump();
           Prototype->getFunctionType()->dump();

llvm/lib/Transforms/Utils/VNCoercion.cpp

static T *coerceAvailableValueToLoadTypeHelper(T *StoredVal, Type *LoadedTy,
   assert(canCoerceMustAliasedValueToLoad(StoredVal, LoadedTy, DL) &&
          "precondition violation - materialization can't fail");
   if (auto *C = dyn_cast<Constant>(StoredVal))
     StoredVal = ConstantFoldConstant(C, DL);
 
   // If this is already the right type, just return it.
   Type *StoredValTy = StoredVal->getType();
 
+  // Return if a bitcast has been introduced before and if types matches.
+  if (StoredValTy == LoadedTy) {
+    return StoredVal;
+  }
+
   uint64_t StoredValSize = DL.getTypeSizeInBits(StoredValTy).getFixedSize();
   uint64_t LoadedValSize = DL.getTypeSizeInBits(LoadedTy).getFixedSize();
 
   // If the store and reload are the same size, we can always reuse it.
   if (StoredValSize == LoadedValSize) {
     // Pointer to Pointer -> use bitcast.
     if (StoredValTy->isPtrOrPtrVectorTy() && LoadedTy->isPtrOrPtrVectorTy()) {
       StoredVal = Helper.CreateBitCast(StoredVal, LoadedTy);
static T *getStoreValueForLoadHelper(T *SrcVal, unsigned Offset, Type *LoadTy,
   // so we don't need to do any truncation, etc. This avoids introducing
   // ptrtoint instructions for pointers that may be non-integral.
   if (SrcVal->getType()->isPointerTy() && LoadTy->isPointerTy() &&
       cast<PointerType>(SrcVal->getType())->getAddressSpace() ==
           cast<PointerType>(LoadTy)->getAddressSpace()) {
     return SrcVal;
   }
 
+  // If two pointers are in different address spaces
+  // and if bitcast is valid, introduce a bitcast.
+  if (SrcVal->getType()->isPtrOrPtrVectorTy() && LoadTy->isPtrOrPtrVectorTy() &&
+      (cast<PointerType>(SrcVal->getType())->getAddressSpace() !=
+       cast<PointerType>(LoadTy)->getAddressSpace())) {
+    if (CastInst::castIsValid(Instruction::BitCast, SrcVal->getType(), LoadTy,
+                              DL)) {
+      SrcVal = Helper.CreateBitCast(SrcVal, LoadTy, DL);
+      return SrcVal;
+    }
+  }
+
   uint64_t StoreSize =
       (DL.getTypeSizeInBits(SrcVal->getType()).getFixedSize() + 7) / 8;
   uint64_t LoadSize = (DL.getTypeSizeInBits(LoadTy).getFixedSize() + 7) / 8;
+
   // Compute which bits of the stored value are being used by the load.  Convert
   // to an integer type to start with.
   if (SrcVal->getType()->isPtrOrPtrVectorTy())
     SrcVal = Helper.CreatePtrToInt(SrcVal, DL.getIntPtrType(SrcVal->getType()));
   if (!SrcVal->getType()->isIntegerTy())
     SrcVal = Helper.CreateBitCast(SrcVal, IntegerType::get(Ctx, StoreSize * 8));
 
   // Shift the bits to the least significant depending on endianness.

llvm/test/Transforms/GVN/gvn-eliminate-inttoptr-ptrtoint-for-load.ll

+; RUN: opt -S -gvn < %s | FileCheck %s
+
+; GVN replaces a load that depends on previous store with intoptr/ptrtoint instructions.
+; Instead, replace load with bitcast of pointers from different addrspaces.
+
+target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7"
+
+%struct.S.coerce = type { i32 addrspace(1)* }
+
+define void @test(%struct.S.coerce %s.coerce) #0 {
+; CHECK-LABEL: @test(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %s.sroa.0 = alloca i32*, align 8, addrspace(5)
+; CHECK-NEXT:    %0 = extractvalue %struct.S.coerce %s.coerce, 0
+; CHECK-NEXT:    %1 = bitcast i32* addrspace(5)* %s.sroa.0 to i32 addrspace(1)* addrspace(5)*
+; CHECK-NEXT:    %2 = addrspacecast i32 addrspace(1)* addrspace(5)* %1 to i32 addrspace(1)**
+; CHECK-NEXT:    store i32 addrspace(1)* %0, i32 addrspace(1)** %2, align 8
+; CHECK-NEXT:    %3 = bitcast i32 addrspace(1)* %0 to i32*
+; CHECK-NEXT:    %4 = load i32, i32* %3, align 4, !tbaa !2
+; CHECK-NEXT:    %inc = add nsw i32 %4, 1
+; CHECK-NEXT:    store i32 %inc, i32* %3, align 4, !tbaa !2
+; CHECK-NEXT:    ret void
+;
+
+entry:
+  %s.sroa.0 = alloca i32*, align 8, addrspace(5)
+
+  %0 = extractvalue %struct.S.coerce %s.coerce, 0
+  %1 = bitcast i32* addrspace(5)* %s.sroa.0 to i32 addrspace(1)* addrspace(5)*
+  %2 = addrspacecast i32 addrspace(1)* addrspace(5)* %1 to i32 addrspace(1)**
+  store i32 addrspace(1)* %0, i32 addrspace(1)** %2, align 8
+  
+  %3 = load i32*, i32* addrspace(5)* %s.sroa.0, align 8, !tbaa !2
+  %4 = load i32, i32* %3, align 4, !tbaa !2
+  %inc = add nsw i32 %4, 1
+  store i32 %inc, i32* %3, align 4, !tbaa !2
+    
+  ret void
+}
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 25e22613dfdb4083056e8a951aeb246bea4019f3)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"int", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}

llvm/test/Transforms/GVN/gvn-eliminate-inttoptr-ptrtoint-for-vector-load.ll

+; RUN: opt -S -gvn < %s | FileCheck %s
+
+; GVN replaces a load that depends on previous store with intoptr/ptrtoint instructions.
+; Instead, replace load with bitcast of pointers from different addrspaces.
+
+target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7"
+
+%struct.S.coerce = type { <2 x i32> addrspace(1)* }
+
+define void @test(%struct.S.coerce %s.coerce) #0 {
+; CHECK-LABEL: @test(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %s.sroa.0 = alloca <2 x i32>*, align 8, addrspace(5)
+; CHECK-NEXT:    %0 = extractvalue %struct.S.coerce %s.coerce, 0
+; CHECK-NEXT:    %1 = bitcast <2 x i32>* addrspace(5)* %s.sroa.0 to <2 x i32> addrspace(1)* addrspace(5)*
+; CHECK-NEXT:    %2 = addrspacecast <2 x i32> addrspace(1)* addrspace(5)* %1 to <2 x i32> addrspace(1)**
+; CHECK-NEXT:    store <2 x i32> addrspace(1)* %0, <2 x i32> addrspace(1)** %2, align 8
+; CHECK-NEXT:    %3 = bitcast <2 x i32> addrspace(1)* %0 to <2 x i32>*
+; CHECK-NEXT:    %4 = load <2 x i32>, <2 x i32>* %3, align 4, !tbaa !2
+; CHECK-NEXT:    %inc = add nsw <2 x i32> %4, <i32 1, i32 1>
+; CHECK-NEXT:    store <2 x i32> %inc, <2 x i32>* %3, align 4, !tbaa !2
+; CHECK-NEXT:    ret void
+;
+
+entry:
+  %s.sroa.0 = alloca <2 x i32>*, align 8, addrspace(5)
+
+  %0 = extractvalue %struct.S.coerce %s.coerce, 0
+  %1 = bitcast <2 x i32>* addrspace(5)* %s.sroa.0 to <2 x i32> addrspace(1)* addrspace(5)*
+  %2 = addrspacecast <2 x i32> addrspace(1)* addrspace(5)* %1 to <2 x i32> addrspace(1)**
+  store <2 x i32> addrspace(1)* %0, <2 x i32> addrspace(1)** %2, align 8
+  
+  %3 = load <2 x i32>*, <2 x i32>* addrspace(5)* %s.sroa.0, align 8, !tbaa !2
+  %4 = load <2 x i32>, <2 x i32>* %3, align 4, !tbaa !2
+  %inc = add nsw <2 x i32> %4, <i32 1, i32 1>
+  store <2 x i32> %inc, <2 x i32>* %3, align 4, !tbaa !2
+    
+  ret void
+}
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 25e22613dfdb4083056e8a951aeb246bea4019f3)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"int", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}

llvm/test/Transforms/GVN/gvn-eliminate-inttoptr-ptrtoint-for-vector-ptr-load.ll

+; RUN: opt -S -gvn < %s | FileCheck %s
+
+; GVN replaces a load that depends on previous store with intoptr/ptrtoint instructions.
+; Instead, replace load with bitcast of pointers from different addrspaces.
+
+target datalayout = "e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7"
+
+%struct.S.coerce = type { <2 x i32*> addrspace(1)* }
+
+define void @test(%struct.S.coerce %s.coerce) #0 {
+; CHECK-LABEL: @test(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    %s.sroa.0 = alloca <2 x i32*>*, align 8, addrspace(5)
+; CHECK-NEXT:    %0 = extractvalue %struct.S.coerce %s.coerce, 0
+; CHECK-NEXT:    %1 = bitcast <2 x i32*>* addrspace(5)* %s.sroa.0 to <2 x i32*> addrspace(1)* addrspace(5)*
+; CHECK-NEXT:    %2 = addrspacecast <2 x i32*> addrspace(1)* addrspace(5)* %1 to <2 x i32*> addrspace(1)**
+; CHECK-NEXT:    store <2 x i32*> addrspace(1)* %0, <2 x i32*> addrspace(1)** %2, align 8
+; CHECK-NEXT:    %3 = bitcast <2 x i32*> addrspace(1)* %0 to <2 x i32*>*
+; CHECK-NEXT:    %4 = load <2 x i32*>, <2 x i32*>* %3, align 4, !tbaa !2
+; CHECK-NEXT:    store <2 x i32*> %4, <2 x i32*>* %3, align 4, !tbaa !2
+; CHECK-NEXT:    ret void
+;
+
+entry:
+  %s.sroa.0 = alloca <2 x i32*>*, align 8, addrspace(5)
+
+  %0 = extractvalue %struct.S.coerce %s.coerce, 0
+  %1 = bitcast <2 x i32*>* addrspace(5)* %s.sroa.0 to <2 x i32*> addrspace(1)* addrspace(5)*
+  %2 = addrspacecast <2 x i32*> addrspace(1)* addrspace(5)* %1 to <2 x i32*> addrspace(1)**
+  store <2 x i32*> addrspace(1)* %0, <2 x i32*> addrspace(1)** %2, align 8
+  
+  %3 = load <2 x i32*>*, <2 x i32*>* addrspace(5)* %s.sroa.0, align 8, !tbaa !2
+  %4 = load <2 x i32*>, <2 x i32*>* %3, align 4, !tbaa !2
+  store <2 x i32*> %4, <2 x i32*>* %3, align 4, !tbaa !2
+  ret void
+}
+
+!llvm.module.flags = !{!0}
+!llvm.ident = !{!1}
+
+!0 = !{i32 1, !"wchar_size", i32 4}
+!1 = !{!"clang version 11.0.0 ([e-mail]:llvm/llvm-project.git 25e22613dfdb4083056e8a951aeb246bea4019f3)"}
+!2 = !{!3, !3, i64 0}
+!3 = !{!"int", !4, i64 0}
+!4 = !{!"omnipotent char", !5, i64 0}
+!5 = !{!"Simple C++ TBAA"}

llvm/test/Verifier/bitcast-vector-pointer-as-neg.ll

-; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s
 
 target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
 
-; CHECK: error: invalid cast opcode for cast from '<4 x i32 addrspace(1)*>' to '<2 x i32 addrspace(2)*>'
-
 ; The pointer in addrspace 1 of the size 16 while pointer in addrspace 2 of the size 32.
 ; Converting 4 element array of pointers from addrspace 2 to 2 element array in addrspace 2
-; has the same total bit length but bitcast still does not allow conversion into
-; different addrspace.
-define <2 x i32 addrspace(2)*> @vector_illegal_bitcast_as_1_to_2(<4 x i32 addrspace(1)*> %p) {
+; has the same total bit length
+
+define <2 x i32 addrspace(2)*> @vector_legal_bitcast_as_1_to_2(<4 x i32 addrspace(1)*> %p) {
    %cast = bitcast <4 x i32 addrspace(1)*> %p to <2 x i32 addrspace(2)*>
    ret <2 x i32 addrspace(2)*> %cast
 }
 

llvm/test/Verifier/bitcast-vector-pointer-different-addrspace-illegal.ll

+; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
+
+target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
+
+; CHECK: error: invalid cast opcode for cast from '<4 x i32 addrspace(1)*>' to '<4 x i32 addrspace(2)*>'
+define <4 x i32 addrspace(2)*> @vector_illegal_bitcast_as_1_to_2(<4 x i32 addrspace(1)*> %p) {
+   %cast = bitcast <4 x i32 addrspace(1)*> %p to <4 x i32 addrspace(2)*>
+   ret <4 x i32 addrspace(2)*> %cast
+}

llvm/test/Verifier/bitcast-vector-pointer-neg.ll

-; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
+; RUN: llvm-as -disable-output %s
 
 target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
 
-; CHECK: error: invalid cast opcode for cast from '<2 x i32*>' to 'i64*'
+; The pointer in addrspace 1 of the size 16 while pointer in addrspace 2 of the size 32.
+; Converting 4 element array of pointers from addrspace 2 to 2 element array in addrspace 2
+; has the same total bit length
 
-define i64* @illegal_bitcast_vector_of_pointers_to_pointer(<2 x i32*> %a) {
-  %b = bitcast <2 x i32*> %a to i64*
-  ret i64* %b
+define <2 x i32 addrspace(2)*> @vector_legal_bitcast_as_1_to_2(<4 x i32 addrspace(1)*> %p) {
+   %cast = bitcast <4 x i32 addrspace(1)*> %p to <2 x i32 addrspace(2)*>
+   ret <2 x i32 addrspace(2)*> %cast
 }

llvm/test/Verifier/bitcast-vector-pointer-pos.ll

 ; RUN: llvm-as -disable-output %s
 
 target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
 
 define <1 x i32*> @vector_legal_bitcast_pointer_to_vector_of_pointers(i64* %a) {
   %b = bitcast i64* %a to <1 x i32*>
   ret <1 x i32*> %b
 }
 
 define i64* @vector_legal_bitcast_vector_of_pointers_to_pointer(<1 x i32*> %a) {
   %b = bitcast <1 x i32*> %a to i64*
   ret i64* %b
 }
 
+define <2 x i32 addrspace(2)*> @vector_legal_bitcast_vector_of_pointers_to_vector_of_pointers(<2 x i32*> %a) {
+  %c = bitcast <2 x i32*> %a to <2 x i32 addrspace(2)*>
+  ret <2 x i32 addrspace(2)*> %c
+}

llvm/test/Verifier/bitcast-vector-pointer-same-addrspace.ll

+; RUN: not llvm-as -disable-output %s 2>&1 | FileCheck %s
+
+target datalayout = "e-p:32:32:32-p1:16:16:16-p2:32:32:32-i1:8:32-i8:8:32-i16:16:32-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:32:64-v128:32:128-a0:0:32-n8:16:32"
+
+; CHECK: error: invalid cast opcode for cast from '<4 x i32 addrspace(1)*>' to '<2 x i32 addrspace(1)*>'
+
+; Converting 4 element array of pointers from addrspace 1 to 2 element array in addrspace 1
+; is invalid since the vector sizes dont match
+define <2 x i32 addrspace(1)*> @vector_illegal_bitcast_1(<4 x i32 addrspace(1)*> %p) {
+   %cast = bitcast <4 x i32 addrspace(1)*> %p to <2 x i32 addrspace(1)*>
+   ret <2 x i32 addrspace(1)*> %cast
+}
+

llvm/unittests/IR/InstructionsTest.cpp

TEST(InstructionsTest, BranchInst) {
 
   delete bb0;
   delete bb1;
 }
 
 TEST(InstructionsTest, CastInst) {
   LLVMContext C;
 
+  DataLayout DL("e-p:64:64-p1:64:64-p2:32:32-p3:32:32-p4:64:64-p5:32:32-"
+                "p6:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-"
+                "v256:256-v512:512-v1024:1024-v2048:2048-n32:64-S32-A5-ni:7");
+
   Type *Int8Ty = Type::getInt8Ty(C);
   Type *Int16Ty = Type::getInt16Ty(C);
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *Int64Ty = Type::getInt64Ty(C);
   Type *V8x8Ty = FixedVectorType::get(Int8Ty, 8);
   Type *V8x64Ty = FixedVectorType::get(Int64Ty, 8);
   Type *X86MMXTy = Type::getX86_MMXTy(C);
 
TEST(InstructionsTest, CastInst) {
   Type *VScaleV1Int16Ty = ScalableVectorType::get(Int16Ty, 1);
 
   Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
   Type *Int64PtrTy = PointerType::get(Int64Ty, 0);
 
   Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
   Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1);
 
+  Type *Int32PtrAS2Ty = PointerType::get(Int32Ty, 2);
+  Type *Int32PtrAS3Ty = PointerType::get(Int32Ty, 3);
+
   Type *V2Int32PtrAS1Ty = FixedVectorType::get(Int32PtrAS1Ty, 2);
+  Type *V2Int32PtrAS2Ty = FixedVectorType::get(Int32PtrAS2Ty, 2);
   Type *V2Int64PtrAS1Ty = FixedVectorType::get(Int64PtrAS1Ty, 2);
   Type *V4Int32PtrAS1Ty = FixedVectorType::get(Int32PtrAS1Ty, 4);
   Type *VScaleV4Int32PtrAS1Ty = ScalableVectorType::get(Int32PtrAS1Ty, 4);
   Type *V4Int64PtrAS1Ty = FixedVectorType::get(Int64PtrAS1Ty, 4);
 
   Type *V2Int64PtrTy = FixedVectorType::get(Int64PtrTy, 2);
   Type *V2Int32PtrTy = FixedVectorType::get(Int32PtrTy, 2);
   Type *VScaleV2Int32PtrTy = ScalableVectorType::get(Int32PtrTy, 2);
   Type *V4Int32PtrTy = FixedVectorType::get(Int32PtrTy, 4);
   Type *VScaleV4Int32PtrTy = ScalableVectorType::get(Int32PtrTy, 4);
   Type *VScaleV4Int64PtrTy = ScalableVectorType::get(Int64PtrTy, 4);
 
   const Constant* c8 = Constant::getNullValue(V8x8Ty);
   const Constant* c64 = Constant::getNullValue(V8x64Ty);
 
   const Constant *v2ptr32 = Constant::getNullValue(V2Int32PtrTy);
 
   EXPECT_EQ(CastInst::Trunc, CastInst::getCastOpcode(c64, true, V8x8Ty, true));
   EXPECT_EQ(CastInst::SExt, CastInst::getCastOpcode(c8, true, V8x64Ty, true));
 
-  EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, X86MMXTy));
-  EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy, V8x8Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, X86MMXTy));
-  EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty, V8x8Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, V8x64Ty));
-
-  // Check address space casts are rejected since we don't know the sizes here
-  EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, Int32PtrAS1Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrTy));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, V2Int32PtrAS1Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrTy));
-  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty));
+  EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, X86MMXTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(X86MMXTy, V8x8Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, X86MMXTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V8x64Ty, V8x8Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V8x8Ty, V8x64Ty, DL));
+
+  // Check validity of casts here
+  EXPECT_TRUE(CastInst::isBitCastable(Int32PtrAS2Ty, Int32PtrAS3Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrAS2Ty, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int32PtrAS1Ty, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(Int32PtrAS1Ty, Int32PtrTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int32PtrAS1Ty, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int64PtrAS1Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V2Int32PtrAS2Ty, DL));
   EXPECT_EQ(CastInst::AddrSpaceCast, CastInst::getCastOpcode(v2ptr32, true,
                                                              V2Int32PtrAS1Ty,
                                                              true));
 
   // Test mismatched number of elements for pointers
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int64PtrAS1Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty, V2Int32PtrAS1Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int32PtrAS1Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, V2Int32PtrTy));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int32PtrTy));
-
-  EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy));
-  EXPECT_FALSE(CastInst::isBitCastable(DoubleTy, FloatTy));
-  EXPECT_FALSE(CastInst::isBitCastable(FloatTy, DoubleTy));
-  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
-  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy));
-  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty));
-  EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy));
-  EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy));
-  EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty));
-
-  EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int32Ty, Int64Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, Int32Ty));
-
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int64Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, V2Int32PtrTy));
-  EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy));
-  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty, V2Int64Ty));
-  EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty, V2Int32Ty));
-
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int64PtrAS1Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V4Int64PtrAS1Ty, V2Int32PtrAS1Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrAS1Ty, V4Int32PtrAS1Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int32PtrTy, V2Int32PtrTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int32PtrTy, DL));
+
+  EXPECT_TRUE(CastInst::isBitCastable(Int32PtrTy, Int64PtrTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(DoubleTy, FloatTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(FloatTy, DoubleTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, FloatTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(FloatTy, Int32Ty, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(Int16Ty, HalfTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(Int32Ty, FloatTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, Int64Ty, DL));
+
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32Ty, V4Int16Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int32Ty, Int64Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, Int32Ty, DL));
+
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32PtrTy, Int64Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(Int64Ty, V2Int32PtrTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int64PtrTy, V2Int32PtrTy, DL));
+  EXPECT_TRUE(CastInst::isBitCastable(V2Int32PtrTy, V2Int64PtrTy, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int32Ty, V2Int64Ty, DL));
+  EXPECT_FALSE(CastInst::isBitCastable(V2Int64Ty, V2Int32Ty, DL));
 
   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
                                      Constant::getNullValue(V4Int32PtrTy),
                                      V2Int32PtrTy));
   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
                                      Constant::getNullValue(V2Int32PtrTy),
                                      V4Int32PtrTy));
 
EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
                                      V2Int32Ty));
   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
                                      Constant::getNullValue(VScaleV2Int64Ty),
                                      V2Int64Ty));
   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
                                      Constant::getNullValue(VScaleV4Int16Ty),
                                      V4Int16Ty));
 
+  // Bit casting between pointers from different addrspace
+  EXPECT_TRUE(CastInst::castIsValid(Instruction::BitCast,
+                                    Constant::getNullValue(Int32PtrAS2Ty),
+                                    Int32PtrAS3Ty, DL));
+  EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,
+                                     Constant::getNullValue(Int32PtrAS1Ty),
+                                     Int32PtrAS2Ty, DL));
+
   // Bit casting scalable vectors to scalable vectors.
   EXPECT_TRUE(CastInst::castIsValid(Instruction::BitCast,
                                     Constant::getNullValue(VScaleV4Int16Ty),
                                     VScaleV2Int32Ty));
   EXPECT_TRUE(CastInst::castIsValid(Instruction::BitCast,
                                     Constant::getNullValue(VScaleV2Int32Ty),
                                     VScaleV4Int16Ty));
   EXPECT_FALSE(CastInst::castIsValid(Instruction::BitCast,