[LLParser] Print mismatched types in error message

[aeubanks]

Summary

Helps with debugging invalid handcrafted IR.

[rnk]

lgtm

llvm/lib/AsmParser/LLParser.cpp

 
 // If there was an explicit dso_local, update GV. In the absence of an explicit
 // dso_local we keep the default value.
 static void maybeSetDSOLocal(bool DSOLocal, GlobalValue &GV) {
   if (DSOLocal)
     GV.setDSOLocal(true);
 }
 
+static std::string typeComparisonErrorMessage(StringRef Message, Type *Ty1,
+                                              Type *Ty2) {
+  std::string ErrString;
+  raw_string_ostream ErrOS(ErrString);
+  ErrOS << Message << " (" << *Ty1 << " vs " << *Ty2 << ")";
+  return ErrOS.str();
+}
+
 /// parseIndirectSymbol:
 ///   ::= GlobalVar '=' OptionalLinkage OptionalPreemptionSpecifier
 ///                     OptionalVisibility OptionalDLLStorageClass
 ///                     OptionalThreadLocal OptionalUnnamedAddr
 ///                     'alias|ifunc' IndirectSymbol IndirectSymbolAttr*
 ///
 /// IndirectSymbol
 ///   ::= TypeAndValue
bool LLParser::parseIndirectSymbol(const std::string &Name, LocTy NameLoc,
   }
 
   Type *AliaseeType = Aliasee->getType();
   auto *PTy = dyn_cast<PointerType>(AliaseeType);
   if (!PTy)
     return error(AliaseeLoc, "An alias or ifunc must have pointer type");
   unsigned AddrSpace = PTy->getAddressSpace();
 
-  if (IsAlias && Ty != PTy->getElementType())
-    return error(ExplicitTypeLoc,
-                 "explicit pointee type doesn't match operand's pointee type");
+  if (IsAlias && Ty != PTy->getElementType()) {
+    return error(
+        ExplicitTypeLoc,
+        typeComparisonErrorMessage(
+            "explicit pointee type doesn't match operand's pointee type", Ty,
+            PTy->getElementType()));
+  }
 
-  if (!IsAlias && !PTy->getElementType()->isFunctionTy())
+  if (!IsAlias && !PTy->getElementType()->isFunctionTy()) {
     return error(ExplicitTypeLoc,
                  "explicit pointee type should be a function type");
+  }
 
   GlobalValue *GVal = nullptr;
 
   // See if the alias was forward referenced, if so, prepare to replace the
   // forward reference.
   if (!Name.empty()) {
     GVal = M->getNamedValue(Name);
     if (GVal) {
case lltok::kw_select: {
 
     if (Opc == Instruction::GetElementPtr) {
       if (Elts.size() == 0 ||
           !Elts[0]->getType()->isPtrOrPtrVectorTy())
         return error(ID.Loc, "base of getelementptr must be a pointer");
 
       Type *BaseType = Elts[0]->getType();
       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
-      if (Ty != BasePointerType->getElementType())
+      if (Ty != BasePointerType->getElementType()) {
         return error(
             ExplicitTypeLoc,
-            "explicit pointee type doesn't match operand's pointee type");
+            typeComparisonErrorMessage(
+                "explicit pointee type doesn't match operand's pointee type",
+                Ty, BasePointerType->getElementType()));
+      }
 
       unsigned GEPWidth =
           BaseType->isVectorTy()
               ? cast<FixedVectorType>(BaseType)->getNumElements()
               : 0;
 
       ArrayRef<Constant *> Indices(Elts.begin() + 1, Elts.end());
       for (Constant *Val : Indices) {
int LLParser::parseLoad(Instruction *&Inst, PerFunctionState &PFS) {
   if (!Val->getType()->isPointerTy() || !Ty->isFirstClassType())
     return error(Loc, "load operand must be a pointer to a first class type");
   if (isAtomic && !Alignment)
     return error(Loc, "atomic load must have explicit non-zero alignment");
   if (Ordering == AtomicOrdering::Release ||
       Ordering == AtomicOrdering::AcquireRelease)
     return error(Loc, "atomic load cannot use Release ordering");
 
-  if (Ty != cast<PointerType>(Val->getType())->getElementType())
-    return error(ExplicitTypeLoc,
-                 "explicit pointee type doesn't match operand's pointee type");
+  if (Ty != cast<PointerType>(Val->getType())->getElementType()) {
+    return error(
+        ExplicitTypeLoc,
+        typeComparisonErrorMessage(
+            "explicit pointee type doesn't match operand's pointee type", Ty,
+            cast<PointerType>(Val->getType())->getElementType()));
+  }
   SmallPtrSet<Type *, 4> Visited;
   if (!Alignment && !Ty->isSized(&Visited))
     return error(ExplicitTypeLoc, "loading unsized types is not allowed");
   if (!Alignment)
     Alignment = M->getDataLayout().getABITypeAlign(Ty);
   Inst = new LoadInst(Ty, Val, "", isVolatile, *Alignment, Ordering, SSID);
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
if (parseType(Ty) ||
       parseTypeAndValue(Ptr, Loc, PFS))
     return true;
 
   Type *BaseType = Ptr->getType();
   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());
   if (!BasePointerType)
     return error(Loc, "base of getelementptr must be a pointer");
 
-  if (Ty != BasePointerType->getElementType())
-    return error(ExplicitTypeLoc,
-                 "explicit pointee type doesn't match operand's pointee type");
+  if (Ty != BasePointerType->getElementType()) {
+    return error(
+        ExplicitTypeLoc,
+        typeComparisonErrorMessage(
+            "explicit pointee type doesn't match operand's pointee type", Ty,
+            BasePointerType->getElementType()));
+  }
 
   SmallVector<Value*, 16> Indices;
   bool AteExtraComma = false;
   // GEP returns a vector of pointers if at least one of parameters is a vector.
   // All vector parameters should have the same vector width.
   ElementCount GEPWidth = BaseType->isVectorTy()
                               ? cast<VectorType>(BaseType)->getElementCount()
                               : ElementCount::getFixed(0);

llvm/test/Assembler/invalid-alias-mismatched-explicit-type.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
-; CHECK: <stdin>:4:12: error: explicit pointee type doesn't match operand's pointee type
+; CHECK: <stdin>:4:12: error: explicit pointee type doesn't match operand's pointee type (i1 vs i2)
 @y = global i2 0
 @x = alias i1, i2* @y

llvm/test/Assembler/invalid-gep-mismatched-explicit-type.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
-; CHECK: <stdin>:4:22: error: explicit pointee type doesn't match operand's pointee type
+; CHECK: <stdin>:4:22: error: explicit pointee type doesn't match operand's pointee type (i16 vs i32)
 define void @test(i32* %t) {
   %x = getelementptr i16, i32* %t, i32 0
   ret void
 }

llvm/test/Assembler/invalid-load-mismatched-explicit-type.ll

 ; RUN: not llvm-as < %s 2>&1 | FileCheck %s
-; CHECK: <stdin>:4:13: error: explicit pointee type doesn't match operand's pointee type
+; CHECK: <stdin>:4:13: error: explicit pointee type doesn't match operand's pointee type (i16 vs i32)
 define void @test(i32* %t) {
   %x = load i16, i32* %t
   ret void
 }