libproc_macro: Manual Clone for Literal

The Literal type may contain foreign byte array when representing a byte
array or a string. This means auto deriving the Clone trait would only
perform a shallow copy of the pointer rather than a deep copy. This
behavior would lead to use-after-free when a literal is cloned and then
dropped.

ChangeLog:

	* librust/proc_macro/rust/bridge/literal.rs: Implement Clone
	manually.

Signed-off-by: Pierre-Emmanuel Patry <pierre-emmanuel.patry@embecosm.com>

1 files changed, 19 insertions, 3 deletions

diff --git a/librust/proc_macro/rust/bridge/literal.rs b/librust/proc_macro/rust/bridge/literal.rs
index e883e6b..3251403 100644
--- a/librust/proc_macro/rust/bridge/literal.rs
+++ b/librust/proc_macro/rust/bridge/literal.rs
@@ -13,7 +13,7 @@ extern "C" {
 }
 
 #[repr(C)]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum Unsigned {
     Unsigned8(u8),
     Unsigned16(u16),
@@ -25,7 +25,7 @@ pub enum Unsigned {
 }
 
 #[repr(C)]
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub enum Signed {
     Signed8(i8),
     Signed16(i16),
@@ -37,7 +37,7 @@ pub enum Signed {
 }
 
 #[repr(C)]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum Literal {
     /// String literal internal representation
     ///
@@ -383,3 +383,19 @@ impl FromStr for Literal {
         }
     }
 }
+
+impl Clone for Literal {
+    fn clone(&self) -> Self {
+        match self {
+            Literal::String { data, len } => unsafe { Literal__string(*data, *len) },
+            Literal::ByteString { data, size } => unsafe { Literal__byte_string(*data, *size) },
+            Literal::Char(val) => Literal::Char(*val),
+            Literal::Unsigned(val, suffixed) => Literal::Unsigned(*val, *suffixed),
+            Literal::Signed(val, suffixed) => Literal::Signed(*val, *suffixed),
+            Literal::Usize(val, suffixed) => Literal::Usize(*val, *suffixed),
+            Literal::ISize(val, suffixed) => Literal::ISize(*val, *suffixed),
+            Literal::Float32(val, suffixed) => Literal::Float32(*val, *suffixed),
+            Literal::Float64(val, suffixed) => Literal::Float64(*val, *suffixed),
+        }
+    }
+}