From 2de210ddb61d44bc3916927c8e0fbd6b980d246a Mon Sep 17 00:00:00 2001
From: Jakob Stoklund Olesen <jolesen@mozilla.com>
Date: Tue, 7 Mar 2017 15:13:55 -0800
Subject: [PATCH] Implement From traits on ArgAction for convenience.

---
 lib/cretonne/src/abi.rs           | 12 ++++++++++++
 lib/cretonne/src/isa/riscv/abi.rs | 16 ++++++----------
 2 files changed, 18 insertions(+), 10 deletions(-)

diff --git a/lib/cretonne/src/abi.rs b/lib/cretonne/src/abi.rs
index 8d02de4aca..d011311e7c 100644
--- a/lib/cretonne/src/abi.rs
+++ b/lib/cretonne/src/abi.rs
@@ -23,6 +23,18 @@ pub enum ArgAction {
     Convert(ValueConversion),
 }
 
+impl From<ArgumentLoc> for ArgAction {
+    fn from(x: ArgumentLoc) -> ArgAction {
+        ArgAction::Assign(x)
+    }
+}
+
+impl From<ValueConversion> for ArgAction {
+    fn from(x: ValueConversion) -> ArgAction {
+        ArgAction::Convert(x)
+    }
+}
+
 /// Legalization action to be applied to a value that is being passed to or from a legalized ABI.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ValueConversion {
diff --git a/lib/cretonne/src/isa/riscv/abi.rs b/lib/cretonne/src/isa/riscv/abi.rs
index 9d78abc007..fa158dceb5 100644
--- a/lib/cretonne/src/isa/riscv/abi.rs
+++ b/lib/cretonne/src/isa/riscv/abi.rs
@@ -41,7 +41,7 @@ impl ArgAssigner for Args {
         // Check for a legal type.
         // RISC-V doesn't have SIMD at all, so break all vectors down.
         if !ty.is_scalar() {
-            return ArgAction::Convert(ValueConversion::VectorSplit);
+            return ValueConversion::VectorSplit.into();
         }
 
         // Large integers and booleans are broken down to fit in a register.
@@ -49,19 +49,15 @@ impl ArgAssigner for Args {
             // Align registers and stack to a multiple of two pointers.
             self.regs = align(self.regs, 2);
             self.offset = align(self.offset, 2 * self.pointer_bytes);
-            return ArgAction::Convert(ValueConversion::IntSplit);
+            return ValueConversion::IntSplit.into();
         }
 
         // Small integers are extended to the size of a pointer register.
         if ty.is_int() && ty.bits() < self.pointer_bits {
             match arg.extension {
                 ArgumentExtension::None => {}
-                ArgumentExtension::Uext => {
-                    return ArgAction::Convert(ValueConversion::Uext(self.pointer_type))
-                }
-                ArgumentExtension::Sext => {
-                    return ArgAction::Convert(ValueConversion::Sext(self.pointer_type))
-                }
+                ArgumentExtension::Uext => return ValueConversion::Uext(self.pointer_type).into(),
+                ArgumentExtension::Sext => return ValueConversion::Sext(self.pointer_type).into(),
             }
         }
 
@@ -73,12 +69,12 @@ impl ArgAssigner for Args {
                 GPR.unit(10 + self.regs as usize)
             };
             self.regs += 1;
-            ArgAction::Assign(ArgumentLoc::Reg(reg))
+            ArgumentLoc::Reg(reg).into()
         } else {
             // Assign a stack location.
             let loc = ArgumentLoc::Stack(self.offset);
             self.offset += self.pointer_bytes;
-            ArgAction::Assign(loc)
+            loc.into()
         }
     }
 }