constant: Add support for unary negation.

mozilla · Jun 7, 2022 · e7b814d · e7b814d
1 parent 0ee47b3
commit e7b814d
Show file tree

Hide file tree

Showing 11 changed files with 17 additions and 0 deletions.
diff --git a/src/bindgen/ir/constant.rs b/src/bindgen/ir/constant.rs
@@ -417,6 +417,13 @@ impl Literal {
             syn::Expr::Unary(syn::ExprUnary {
                 ref op, ref expr, ..
             }) => match *op {
+                UnOp::Not(_) => {
+                    let val = Self::load(expr)?;
+                    Ok(Literal::PostfixUnaryOp {
+                        op: "~",
+                        value: Box::new(val),
+                    })
+                },
                 UnOp::Neg(_) => {
                     let val = Self::load(expr)?;
                     Ok(Literal::PostfixUnaryOp {

diff --git a/tests/expectations/bitflags.both.c b/tests/expectations/bitflags.both.c
@@ -50,5 +50,6 @@ typedef struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
diff --git a/tests/expectations/bitflags.both.compat.c b/tests/expectations/bitflags.both.compat.c
@@ -50,6 +50,7 @@ typedef struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

diff --git a/tests/expectations/bitflags.c b/tests/expectations/bitflags.c
@@ -50,5 +50,6 @@ typedef struct {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
diff --git a/tests/expectations/bitflags.compat.c b/tests/expectations/bitflags.compat.c
@@ -50,6 +50,7 @@ typedef struct {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

diff --git a/tests/expectations/bitflags.cpp b/tests/expectations/bitflags.cpp
@@ -119,6 +119,7 @@ struct LargeFlags {
 };
 /// Flag with a very large shift that usually would be narrowed.
 constexpr static const LargeFlags LargeFlags_LARGE_SHIFT = LargeFlags{ /* .bits = */ (uint64_t)(1ull << 44) };
+constexpr static const LargeFlags LargeFlags_INVERTED = LargeFlags{ /* .bits = */ (uint64_t)~(LargeFlags_LARGE_SHIFT).bits };
 
 extern "C" {
 

diff --git a/tests/expectations/bitflags.pyx b/tests/expectations/bitflags.pyx
@@ -34,5 +34,6 @@ cdef extern from *:
     uint64_t bits;
   # Flag with a very large shift that usually would be narrowed.
   const LargeFlags LargeFlags_LARGE_SHIFT # = <LargeFlags>{ <uint64_t>(1ull << 44) }
+  const LargeFlags LargeFlags_INVERTED # = <LargeFlags>{ <uint64_t>~(LargeFlags_LARGE_SHIFT).bits }
 
   void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
diff --git a/tests/expectations/bitflags.tag.c b/tests/expectations/bitflags.tag.c
@@ -50,5 +50,6 @@ struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 void root(struct AlignFlags flags, struct DebugFlags bigger_flags, struct LargeFlags largest_flags);
diff --git a/tests/expectations/bitflags.tag.compat.c b/tests/expectations/bitflags.tag.compat.c
@@ -50,6 +50,7 @@ struct LargeFlags {
  * Flag with a very large shift that usually would be narrowed.
  */
 #define LargeFlags_LARGE_SHIFT (LargeFlags){ .bits = (uint64_t)(1ull << 44) }
+#define LargeFlags_INVERTED (LargeFlags){ .bits = (uint64_t)~(LargeFlags_LARGE_SHIFT).bits }
 
 #ifdef __cplusplus
 extern "C" {

diff --git a/tests/expectations/bitflags.tag.pyx b/tests/expectations/bitflags.tag.pyx
@@ -34,5 +34,6 @@ cdef extern from *:
     uint64_t bits;
   # Flag with a very large shift that usually would be narrowed.
   const LargeFlags LargeFlags_LARGE_SHIFT # = <LargeFlags>{ <uint64_t>(1ull << 44) }
+  const LargeFlags LargeFlags_INVERTED # = <LargeFlags>{ <uint64_t>~(LargeFlags_LARGE_SHIFT).bits }
 
   void root(AlignFlags flags, DebugFlags bigger_flags, LargeFlags largest_flags);
diff --git a/tests/rust/bitflags.rs b/tests/rust/bitflags.rs
@@ -34,6 +34,7 @@ bitflags! {
     pub struct LargeFlags: u64 {
         /// Flag with a very large shift that usually would be narrowed.
         const LARGE_SHIFT = 1u64 << 44;
+        const INVERTED = !Self::LARGE_SHIFT.bits;
     }
 }