From 7dc1def1623748b6c2f1812f1bf2e0153759c8b9 Mon Sep 17 00:00:00 2001
From: Dan Gohman <gohman@apple.com>
Date: Mon, 9 Jun 2008 21:26:13 +0000
Subject: [PATCH] Re-apply 52002, allowing the verifier to accept non-MRV
 struct return types on functions, with adjustments so that it accepts both
 new-style aggregate returns and old-style MRV returns, including those with
 only a single member.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@52157 91177308-0d34-0410-b5e6-96231b3b80d8
---
 lib/VMCore/Verifier.cpp                       | 19 ++++++++++---
 test/Assembler/aggregate-constant-values.ll   | 27 +++++++++++++++++++
 .../aggregate-return-single-value.ll          | 14 ++++++++++
 3 files changed, 56 insertions(+), 4 deletions(-)
 create mode 100644 test/Assembler/aggregate-constant-values.ll
 create mode 100644 test/Assembler/aggregate-return-single-value.ll

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index ac529e3b7f4..0ce7d4c27ce 100644
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -594,7 +594,10 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
     Assert2(N == 0,
             "Found return instr that returns void in Function of non-void "
             "return type!", &RI, F->getReturnType());
-  else if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
+  else if (N == 1 && F->getReturnType() == RI.getOperand(0)->getType()) {
+    // Exactly one return value and it matches the return type. Good.
+  } else if (const StructType *STy = dyn_cast<StructType>(F->getReturnType())) {
+    // The return type is a struct; check for multiple return values.
     Assert2(STy->getNumElements() == N,
             "Incorrect number of return values in ret instruction!",
             &RI, F->getReturnType());
@@ -602,10 +605,18 @@ void Verifier::visitReturnInst(ReturnInst &RI) {
       Assert2(STy->getElementType(i) == RI.getOperand(i)->getType(),
               "Function return type does not match operand "
               "type of return inst!", &RI, F->getReturnType());
+  } else if (const ArrayType *ATy = dyn_cast<ArrayType>(F->getReturnType())) {
+    // The return type is an array; check for multiple return values.
+    Assert2(ATy->getNumElements() == N,
+            "Incorrect number of return values in ret instruction!",
+            &RI, F->getReturnType());
+    for (unsigned i = 0; i != N; ++i)
+      Assert2(ATy->getElementType() == RI.getOperand(i)->getType(),
+              "Function return type does not match operand "
+              "type of return inst!", &RI, F->getReturnType());
   } else {
-    Assert2(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
-            "Function return type does not match operand "
-            "type of return inst!", &RI, F->getReturnType());
+    CheckFailed("Function return type does not match operand "
+                "type of return inst!", &RI, F->getReturnType());
   }
   
   // Check to make sure that the return value has necessary properties for
diff --git a/test/Assembler/aggregate-constant-values.ll b/test/Assembler/aggregate-constant-values.ll
new file mode 100644
index 00000000000..a37d03ebb38
--- /dev/null
+++ b/test/Assembler/aggregate-constant-values.ll
@@ -0,0 +1,27 @@
+; RUN: llvm-as < %s | llvm-dis | grep 7 | count 3
+
+define void @foo({i32, i32}* %x) nounwind {
+  store {i32, i32}{i32 7, i32 9}, {i32, i32}* %x
+  ret void
+}
+define void @foo_empty({}* %x) nounwind {
+  store {}{}, {}* %x
+  ret void
+}
+define void @bar([2 x i32]* %x) nounwind {
+  store [2 x i32][i32 7, i32 9], [2 x i32]* %x
+  ret void
+}
+define void @bar_empty([0 x i32]* %x) nounwind {
+  store [0 x i32][], [0 x i32]* %x
+  ret void
+}
+define void @qux(<{i32, i32}>* %x) nounwind {
+  store <{i32, i32}><{i32 7, i32 9}>, <{i32, i32}>* %x
+  ret void
+}
+define void @qux_empty(<{}>* %x) nounwind {
+  store <{}><{}>, <{}>* %x
+  ret void
+}
+
diff --git a/test/Assembler/aggregate-return-single-value.ll b/test/Assembler/aggregate-return-single-value.ll
new file mode 100644
index 00000000000..02fb59f8a0a
--- /dev/null
+++ b/test/Assembler/aggregate-return-single-value.ll
@@ -0,0 +1,14 @@
+; RUN: llvm-as < %s | llvm-dis
+
+define { i32 } @fooa() nounwind {
+  ret i32 0
+}
+define { i32 } @foob() nounwind {
+  ret {i32}{ i32 0 }
+}
+define [1 x i32] @fooc() nounwind {
+  ret i32 0
+}
+define [1 x i32] @food() nounwind {
+  ret [1 x i32][ i32 0 ]
+}