Add a 'Returned' intrinsic property corresponding to the 'returned' argument attribute.

[hfinkel]

Summary

This will be used by the llvm.noalias intrinsic (D9375).

[majnemer]

LGTM

include/llvm/IR/Intrinsics.td

 // Throws - This intrinsic can throw.
 def Throws : IntrinsicProperty;
 
 // NoCapture - The specified argument pointer is not captured by the intrinsic.
 class NoCapture<int argNo> : IntrinsicProperty {
   int ArgNo = argNo;
 }
 
+// Returned - The specified argument is always the return value of the
+// intrinsic.
+class Returned<int argNo> : IntrinsicProperty {
+  int ArgNo = argNo;
+}
+
 // ReadOnly - The specified argument pointer is not written to through the
 // pointer by the intrinsic.
 class ReadOnly<int argNo> : IntrinsicProperty {
   int ArgNo = argNo;
 }
 
 // WriteOnly - The intrinsic does not read memory through the specified
 // argument pointer.

utils/TableGen/CodeGenIntrinsics.h

struct CodeGenIntrinsic {
     /// isNoReturn - True if the intrinsic is no-return.
     bool isNoReturn;
 
     /// isConvergent - True if the intrinsic is marked as convergent.
     bool isConvergent;
 
     enum ArgAttribute {
       NoCapture,
+      Returned,
       ReadOnly,
       WriteOnly,
       ReadNone
     };
     std::vector<std::pair<unsigned, ArgAttribute> > ArgumentAttributes;
 
     CodeGenIntrinsic(Record *R);
   };
 
   /// LoadIntrinsics - Read all of the intrinsics defined in the specified
   /// .td file.
   std::vector<CodeGenIntrinsic> LoadIntrinsics(const RecordKeeper &RC,
                                                bool TargetOnly);
 }
 
 #endif

utils/TableGen/CodeGenTarget.cpp

else if (Property->getName() == "IntrNoDuplicate")
       isNoDuplicate = true;
     else if (Property->getName() == "IntrConvergent")
       isConvergent = true;
     else if (Property->getName() == "IntrNoReturn")
       isNoReturn = true;
     else if (Property->isSubClassOf("NoCapture")) {
       unsigned ArgNo = Property->getValueAsInt("ArgNo");
       ArgumentAttributes.push_back(std::make_pair(ArgNo, NoCapture));
+    } else if (Property->isSubClassOf("Returned")) {
+      unsigned ArgNo = Property->getValueAsInt("ArgNo");
+      ArgumentAttributes.push_back(std::make_pair(ArgNo, Returned));
     } else if (Property->isSubClassOf("ReadOnly")) {
       unsigned ArgNo = Property->getValueAsInt("ArgNo");
       ArgumentAttributes.push_back(std::make_pair(ArgNo, ReadOnly));
     } else if (Property->isSubClassOf("WriteOnly")) {
       unsigned ArgNo = Property->getValueAsInt("ArgNo");
       ArgumentAttributes.push_back(std::make_pair(ArgNo, WriteOnly));
     } else if (Property->isSubClassOf("ReadNone")) {
       unsigned ArgNo = Property->getValueAsInt("ArgNo");
       ArgumentAttributes.push_back(std::make_pair(ArgNo, ReadNone));
     } else
       llvm_unreachable("Unknown property!");
   }
 
   // Sort the argument attributes for later benefit.
   std::sort(ArgumentAttributes.begin(), ArgumentAttributes.end());
 }

utils/TableGen/IntrinsicEmitter.cpp

if (ae) {
         do {
           switch (intrinsic.ArgumentAttributes[ai].second) {
           case CodeGenIntrinsic::NoCapture:
             if (addComma)
               OS << ",";
             OS << "Attribute::NoCapture";
             addComma = true;
             break;
+          case CodeGenIntrinsic::Returned:
+            if (addComma)
+              OS << ",";
+            OS << "Attribute::Returned";
+            addComma = true;
+            break;
           case CodeGenIntrinsic::ReadOnly:
             if (addComma)
               OS << ",";
             OS << "Attribute::ReadOnly";
             addComma = true;
             break;
           case CodeGenIntrinsic::WriteOnly:
             if (addComma)