[IR] Take const references to LLVMContext

[modocache]

Summary

I tried to pass a const LLVMContext & to llvm::Type::getInt32Ty and
was surprised that it didn't work. Upon closer inspection, llvm::Type
defines many static functions that just access a member of LLVMContext
and LLVMContextImpl, and so -- as far as I can tell -- may as well
take a const reference, not a mutable reference.

I didn't want to change too much at once, so this patch just adds const
to one-line static functions defined on llvm::Type. For example, I left
llvm::Type::getIntNTy alone since that calls llvm::IntegerType::get,
which in turn calls the llvm::Type constructor, which sets the
LLVMContext &Context member of llvm::Type -- changing ALL of those
to use const LLVMContext & seemed like something I could do in a later
patch (if it would work at all, as of now I don't know that it would).

[modocache]

I spoke with @mehdi_amini in the (experimental?) LLVM Discord and his take was that this leaks internal implementation details of LLVMContext: while accessing these types can in fact use const because LLVMContext constructs the types eagerly (as a performance optimization), there's no reason LLVMContext must do so eagerly. Modifying these to take a const reference inhibits the ability to change LLVMContext to lazily construct these types, and so this isn't a desirable change.

llvm/include/llvm/IR/Type.h

public:
   //
 
   /// Return a type based on an identifier.
   static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
 
   //===--------------------------------------------------------------------===//
   // These are the builtin types that are always available.
   //
-  static Type *getVoidTy(LLVMContext &C);
-  static Type *getLabelTy(LLVMContext &C);
-  static Type *getHalfTy(LLVMContext &C);
-  static Type *getFloatTy(LLVMContext &C);
-  static Type *getDoubleTy(LLVMContext &C);
-  static Type *getMetadataTy(LLVMContext &C);
-  static Type *getX86_FP80Ty(LLVMContext &C);
-  static Type *getFP128Ty(LLVMContext &C);
-  static Type *getPPC_FP128Ty(LLVMContext &C);
-  static Type *getX86_MMXTy(LLVMContext &C);
-  static Type *getTokenTy(LLVMContext &C);
+  static Type *getVoidTy(const LLVMContext &C);
+  static Type *getLabelTy(const LLVMContext &C);
+  static Type *getHalfTy(const LLVMContext &C);
+  static Type *getFloatTy(const LLVMContext &C);
+  static Type *getDoubleTy(const LLVMContext &C);
+  static Type *getMetadataTy(const LLVMContext &C);
+  static Type *getX86_FP80Ty(const LLVMContext &C);
+  static Type *getFP128Ty(const LLVMContext &C);
+  static Type *getPPC_FP128Ty(const LLVMContext &C);
+  static Type *getX86_MMXTy(const LLVMContext &C);
+  static Type *getTokenTy(const LLVMContext &C);
   static IntegerType *getIntNTy(LLVMContext &C, unsigned N);
-  static IntegerType *getInt1Ty(LLVMContext &C);
-  static IntegerType *getInt8Ty(LLVMContext &C);
-  static IntegerType *getInt16Ty(LLVMContext &C);
-  static IntegerType *getInt32Ty(LLVMContext &C);
-  static IntegerType *getInt64Ty(LLVMContext &C);
-  static IntegerType *getInt128Ty(LLVMContext &C);
+  static IntegerType *getInt1Ty(const LLVMContext &C);
+  static IntegerType *getInt8Ty(const LLVMContext &C);
+  static IntegerType *getInt16Ty(const LLVMContext &C);
+  static IntegerType *getInt32Ty(const LLVMContext &C);
+  static IntegerType *getInt64Ty(const LLVMContext &C);
+  static IntegerType *getInt128Ty(const LLVMContext &C);
   template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
     int noOfBits = sizeof(ScalarTy) * CHAR_BIT;
     if (std::is_integral<ScalarTy>::value) {
       return (Type*) Type::getIntNTy(C, noOfBits);
     } else if (std::is_floating_point<ScalarTy>::value) {
       switch (noOfBits) {
       case 32:
         return Type::getFloatTy(C);
       case 64:
         return Type::getDoubleTy(C);
       }
     }
     llvm_unreachable("Unsupported type in Type::getScalarTy");
   }
 
   //===--------------------------------------------------------------------===//
   // Convenience methods for getting pointer types with one of the above builtin
   // types as pointee.
   //
-  static PointerType *getHalfPtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getFloatPtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getDoublePtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getX86_FP80PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getFP128PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getPPC_FP128PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getX86_MMXPtrTy(LLVMContext &C, unsigned AS = 0);
+  static PointerType *getHalfPtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getFloatPtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getDoublePtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getX86_FP80PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getFP128PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getPPC_FP128PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getX86_MMXPtrTy(const LLVMContext &C, unsigned AS = 0);
   static PointerType *getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS = 0);
-  static PointerType *getInt1PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getInt8PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getInt16PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getInt32PtrTy(LLVMContext &C, unsigned AS = 0);
-  static PointerType *getInt64PtrTy(LLVMContext &C, unsigned AS = 0);
+  static PointerType *getInt1PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getInt8PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getInt16PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getInt32PtrTy(const LLVMContext &C, unsigned AS = 0);
+  static PointerType *getInt64PtrTy(const LLVMContext &C, unsigned AS = 0);
 
   /// Return a pointer to the current type. This is equivalent to
   /// PointerType::get(Foo, AddrSpace).
   PointerType *getPointerTo(unsigned AddrSpace = 0) const;
 
 private:
   /// Derived types like structures and arrays are sized iff all of the members
   /// of the type are sized as well. Since asking for their size is relatively

llvm/lib/IR/Type.cpp

bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
 
   return cast<StructType>(this)->isSized(Visited);
 }
 
 //===----------------------------------------------------------------------===//
 //                          Primitive 'Type' data
 //===----------------------------------------------------------------------===//
 
-Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
-Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
-Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
-Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
-Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
-Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
-Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
-Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
-Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
-Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
-Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
-
-IntegerType *Type::getInt1Ty(LLVMContext &C) { return &C.pImpl->Int1Ty; }
-IntegerType *Type::getInt8Ty(LLVMContext &C) { return &C.pImpl->Int8Ty; }
-IntegerType *Type::getInt16Ty(LLVMContext &C) { return &C.pImpl->Int16Ty; }
-IntegerType *Type::getInt32Ty(LLVMContext &C) { return &C.pImpl->Int32Ty; }
-IntegerType *Type::getInt64Ty(LLVMContext &C) { return &C.pImpl->Int64Ty; }
-IntegerType *Type::getInt128Ty(LLVMContext &C) { return &C.pImpl->Int128Ty; }
+Type *Type::getVoidTy(const LLVMContext &C) { return &C.pImpl->VoidTy; }
+Type *Type::getLabelTy(const LLVMContext &C) { return &C.pImpl->LabelTy; }
+Type *Type::getHalfTy(const LLVMContext &C) { return &C.pImpl->HalfTy; }
+Type *Type::getFloatTy(const LLVMContext &C) { return &C.pImpl->FloatTy; }
+Type *Type::getDoubleTy(const LLVMContext &C) { return &C.pImpl->DoubleTy; }
+Type *Type::getMetadataTy(const LLVMContext &C) { return &C.pImpl->MetadataTy; }
+Type *Type::getTokenTy(const LLVMContext &C) { return &C.pImpl->TokenTy; }
+Type *Type::getX86_FP80Ty(const LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
+Type *Type::getFP128Ty(const LLVMContext &C) { return &C.pImpl->FP128Ty; }
+Type *Type::getPPC_FP128Ty(const LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
+Type *Type::getX86_MMXTy(const LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
+
+IntegerType *Type::getInt1Ty(const LLVMContext &C) { return &C.pImpl->Int1Ty; }
+IntegerType *Type::getInt8Ty(const LLVMContext &C) { return &C.pImpl->Int8Ty; }
+IntegerType *Type::getInt16Ty(const LLVMContext &C) { return &C.pImpl->Int16Ty; }
+IntegerType *Type::getInt32Ty(const LLVMContext &C) { return &C.pImpl->Int32Ty; }
+IntegerType *Type::getInt64Ty(const LLVMContext &C) { return &C.pImpl->Int64Ty; }
+IntegerType *Type::getInt128Ty(const LLVMContext &C) { return &C.pImpl->Int128Ty; }
 
 IntegerType *Type::getIntNTy(LLVMContext &C, unsigned N) {
   return IntegerType::get(C, N);
 }
 
-PointerType *Type::getHalfPtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getHalfPtrTy(const LLVMContext &C, unsigned AS) {
   return getHalfTy(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getFloatPtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getFloatPtrTy(const LLVMContext &C, unsigned AS) {
   return getFloatTy(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getDoublePtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getDoublePtrTy(const LLVMContext &C, unsigned AS) {
   return getDoubleTy(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getX86_FP80PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getX86_FP80PtrTy(const LLVMContext &C, unsigned AS) {
   return getX86_FP80Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getFP128PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getFP128PtrTy(const LLVMContext &C, unsigned AS) {
   return getFP128Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getPPC_FP128PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getPPC_FP128PtrTy(const LLVMContext &C, unsigned AS) {
   return getPPC_FP128Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getX86_MMXPtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getX86_MMXPtrTy(const LLVMContext &C, unsigned AS) {
   return getX86_MMXTy(C)->getPointerTo(AS);
 }
 
 PointerType *Type::getIntNPtrTy(LLVMContext &C, unsigned N, unsigned AS) {
   return getIntNTy(C, N)->getPointerTo(AS);
 }
 
-PointerType *Type::getInt1PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getInt1PtrTy(const LLVMContext &C, unsigned AS) {
   return getInt1Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getInt8PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getInt8PtrTy(const LLVMContext &C, unsigned AS) {
   return getInt8Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getInt16PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getInt16PtrTy(const LLVMContext &C, unsigned AS) {
   return getInt16Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getInt32PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getInt32PtrTy(const LLVMContext &C, unsigned AS) {
   return getInt32Ty(C)->getPointerTo(AS);
 }
 
-PointerType *Type::getInt64PtrTy(LLVMContext &C, unsigned AS) {
+PointerType *Type::getInt64PtrTy(const LLVMContext &C, unsigned AS) {
   return getInt64Ty(C)->getPointerTo(AS);
 }
 
 //===----------------------------------------------------------------------===//
 //                       IntegerType Implementation
 //===----------------------------------------------------------------------===//
 
 IntegerType *IntegerType::get(LLVMContext &C, unsigned NumBits) {