[opaque pointer type] Add textual IR support for explicit type parameter to load instruction

[dblaikie]

Summary

Essentially the same as the GEP change under review in
http://reviews.llvm.org/D7636

A similar migration script can be used to update test cases, though a few more
test case improvements/changes were required this time around: (r229269-r229278)

import fileinput
import sys
import re

pat = re.compile(r"((?:=|:|^)\s*load (?:atomic )?(?:volatile )?(.*?))(| addrspace\(\d+\) *)\*($| *(?:%|@|null|undef|blockaddress|getelementptr|addrspacecast|bitcast|inttoptr|\[\[[a-zA-Z]|\{\{).*$)")

for line in sys.stdin:

sys.stdout.write(re.sub(pat, r"\1, \2\3*\4", line))

[grosser]

I did not test this yet on the Polly code, but don't expect any issues here.

[dblaikie]

In D7649#123880, @grosser wrote:

I did not test this yet on the Polly code, but don't expect any issues here.

Thanks - given how many IR changes I'm going to be making, I should/will just setup Polly myself.

At least for a few more patches I'll continue to at least CC a few core owners such as yourself just so people know where things are going, have the migration scripts for any out-of-tree tests, etc.

[dblaikie]

ping

[• rafael]

Needs tests for the error cases.

lib/AsmParser/LLParser.cpp

5169

clang-format please.

5187

This is user input, it can fail.

[dblaikie]

rebase, improve error handling, test error handling

[dexonsmith]

LGTM.

[• rafael]

LGTM

lib/AsmParser/LLParser.cpp

int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
   }
 
   bool isVolatile = false;
   if (Lex.getKind() == lltok::kw_volatile) {
     isVolatile = true;
     Lex.Lex();
   }
 
+  Type *Ty = nullptr;
+  if (ParseType(Ty)) return true;
+  ParseToken(lltok::comma, "expected comma after getelementptr's type");
+
   if (ParseTypeAndValue(Val, Loc, PFS) ||
       ParseScopeAndOrdering(isAtomic, Scope, Ordering) ||
       ParseOptionalCommaAlign(Alignment, AteExtraComma))
     return true;
 
   if (!Val->getType()->isPointerTy() ||
       !cast<PointerType>(Val->getType())->getElementType()->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 == Release || Ordering == AcquireRelease)
     return Error(Loc, "atomic load cannot use Release ordering");
 
   Inst = new LoadInst(Val, "", isVolatile, Alignment, Ordering, Scope);
+
+  assert(Ty == Inst->getType());
+
   return AteExtraComma ? InstExtraComma : InstNormal;
 }
 
 /// ParseStore
 
 ///   ::= 'store' 'volatile'? TypeAndValue ',' TypeAndValue (',' 'align' i32)?
 ///   ::= 'store' 'atomic' 'volatile'? TypeAndValue ',' TypeAndValue
 ///       'singlethread'? AtomicOrdering (',' 'align' i32)?

lib/IR/AsmWriter.cpp

void AssemblyWriter::printInstruction(const Instruction &I) {
   } else if (isa<VAArgInst>(I)) {
     if (Operand) {
       Out << ' ';
       writeOperand(Operand, true);   // Work with broken code
     }
     Out << ", ";
     TypePrinter.print(I.getType(), Out);
   } else if (Operand) {   // Print the normal way.
+    if (auto *LI = dyn_cast<LoadInst>(&I)) {
+      Out << ' ';
+      TypePrinter.print(LI->getType(), Out);
+      Out << ", ";
+    }
 
     // PrintAllTypes - Instructions who have operands of all the same type
     // omit the type from all but the first operand.  If the instruction has
     // different type operands (for example br), then they are all printed.
     bool PrintAllTypes = false;
     Type *TheType = Operand->getType();
 
     // Select, Store and ShuffleVector always print all types.