diff --git a/src/bindgen/ir/constant.rs b/src/bindgen/ir/constant.rs
index c181c346..612a2f51 100644
--- 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
index 6003cfda..b5cb6a7c 100644
--- 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
index e5b560bb..35726624 100644
--- 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
index f8148db9..9af76af4 100644
--- 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
index 84b38e35..863de08b 100644
--- 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
index 49dadbad..9df48b69 100644
--- 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
index 68639f8b..e3d10401 100644
--- 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
index 0492d120..c4be368d 100644
--- 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
index 52c1e8de..d12ba40f 100644
--- 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
index ba2d37f7..d5f2df6d 100644
--- 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
index 4d05cb08..7e78bd81 100644
--- 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;
     }
 }