diff --git a/include/gc_allocator.h b/include/gc_allocator.h
index 255e0d3f8..f8d069d89 100644
--- a/include/gc_allocator.h
+++ b/include/gc_allocator.h
@@ -124,34 +124,39 @@ class gc_allocator {
     typedef gc_allocator<GC_Tp1> other;
   };
 
-  gc_allocator() GC_NOEXCEPT {}
-  gc_allocator(const gc_allocator&) GC_NOEXCEPT {}
+  GC_CONSTEXPR gc_allocator() GC_NOEXCEPT {}
+  GC_CONSTEXPR gc_allocator(const gc_allocator&) GC_NOEXCEPT {}
 # ifndef GC_NO_MEMBER_TEMPLATES
     template <class GC_Tp1> GC_ATTR_EXPLICIT
-    gc_allocator(const gc_allocator<GC_Tp1>&) GC_NOEXCEPT {}
+    GC_CONSTEXPR gc_allocator(const gc_allocator<GC_Tp1>&) GC_NOEXCEPT {}
 # endif
-  ~gc_allocator() GC_NOEXCEPT {}
+  GC_CONSTEXPR ~gc_allocator() GC_NOEXCEPT {}
 
-  pointer address(reference GC_x) const { return &GC_x; }
-  const_pointer address(const_reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR pointer address(reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR const_pointer address(const_reference GC_x) const {
+    return &GC_x;
+  }
 
   // GC_n is permitted to be 0.  The C++ standard says nothing about what
   // the return value is when GC_n == 0.
-  GC_Tp* allocate(size_type GC_n, const void* = 0) {
+  GC_CONSTEXPR GC_Tp* allocate(size_type GC_n, const void* = 0) {
     GC_type_traits<GC_Tp> traits;
     return static_cast<GC_Tp *>(GC_selective_alloc(GC_n * sizeof(GC_Tp),
-                                                   traits.GC_is_ptr_free,
-                                                   false));
+                                        traits.GC_is_ptr_free, false));
   }
 
-  void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT
-    { GC_FREE(__p); }
+  GC_CONSTEXPR void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT {
+    GC_FREE(__p);
+  }
 
-  size_type max_size() const GC_NOEXCEPT
+  GC_CONSTEXPR size_type max_size() const GC_NOEXCEPT
     { return size_t(-1) / sizeof(GC_Tp); }
 
-  void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
-  void destroy(pointer __p) { __p->~GC_Tp(); }
+  GC_CONSTEXPR void construct(pointer __p, const GC_Tp& __val) {
+    new(__p) GC_Tp(__val);
+  }
+
+  GC_CONSTEXPR void destroy(pointer __p) { __p->~GC_Tp(); }
 };
 
 template<>
@@ -170,16 +175,14 @@ class gc_allocator<void> {
 
 
 template <class GC_T1, class GC_T2>
-inline bool operator==(const gc_allocator<GC_T1>&,
-                       const gc_allocator<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator==(const gc_allocator<GC_T1>&,
+                                    const gc_allocator<GC_T2>&) GC_NOEXCEPT {
   return true;
 }
 
 template <class GC_T1, class GC_T2>
-inline bool operator!=(const gc_allocator<GC_T1>&,
-                       const gc_allocator<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator!=(const gc_allocator<GC_T1>&,
+                                    const gc_allocator<GC_T2>&) GC_NOEXCEPT {
   return false;
 }
 
@@ -200,36 +203,41 @@ class gc_allocator_ignore_off_page {
     typedef gc_allocator_ignore_off_page<GC_Tp1> other;
   };
 
-  gc_allocator_ignore_off_page() GC_NOEXCEPT {}
-  gc_allocator_ignore_off_page(const gc_allocator_ignore_off_page&)
-    GC_NOEXCEPT {}
+  GC_CONSTEXPR gc_allocator_ignore_off_page() GC_NOEXCEPT {}
+  GC_CONSTEXPR gc_allocator_ignore_off_page(
+                const gc_allocator_ignore_off_page&) GC_NOEXCEPT {}
 # ifndef GC_NO_MEMBER_TEMPLATES
     template <class GC_Tp1> GC_ATTR_EXPLICIT
-    gc_allocator_ignore_off_page(const gc_allocator_ignore_off_page<GC_Tp1>&)
-      GC_NOEXCEPT {}
+    GC_CONSTEXPR gc_allocator_ignore_off_page(
+                const gc_allocator_ignore_off_page<GC_Tp1>&) GC_NOEXCEPT {}
 # endif
-  ~gc_allocator_ignore_off_page() GC_NOEXCEPT {}
+  GC_CONSTEXPR ~gc_allocator_ignore_off_page() GC_NOEXCEPT {}
 
-  pointer address(reference GC_x) const { return &GC_x; }
-  const_pointer address(const_reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR pointer address(reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR const_pointer address(const_reference GC_x) const {
+    return &GC_x;
+  }
 
   // GC_n is permitted to be 0.  The C++ standard says nothing about what
   // the return value is when GC_n == 0.
-  GC_Tp* allocate(size_type GC_n, const void* = 0) {
+  GC_CONSTEXPR GC_Tp* allocate(size_type GC_n, const void* = 0) {
     GC_type_traits<GC_Tp> traits;
     return static_cast<GC_Tp *>(GC_selective_alloc(GC_n * sizeof(GC_Tp),
-                                                   traits.GC_is_ptr_free,
-                                                   true));
+                                        traits.GC_is_ptr_free, true));
   }
 
-  void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT
-    { GC_FREE(__p); }
+  GC_CONSTEXPR void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT {
+    GC_FREE(__p);
+  }
 
-  size_type max_size() const GC_NOEXCEPT
+  GC_CONSTEXPR size_type max_size() const GC_NOEXCEPT
     { return size_t(-1) / sizeof(GC_Tp); }
 
-  void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
-  void destroy(pointer __p) { __p->~GC_Tp(); }
+  GC_CONSTEXPR void construct(pointer __p, const GC_Tp& __val) {
+    new(__p) GC_Tp(__val);
+  }
+
+  GC_CONSTEXPR void destroy(pointer __p) { __p->~GC_Tp(); }
 };
 
 template<>
@@ -247,16 +255,14 @@ class gc_allocator_ignore_off_page<void> {
 };
 
 template <class GC_T1, class GC_T2>
-inline bool operator==(const gc_allocator_ignore_off_page<GC_T1>&,
-                       const gc_allocator_ignore_off_page<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator==(const gc_allocator_ignore_off_page<GC_T1>&,
+                const gc_allocator_ignore_off_page<GC_T2>&) GC_NOEXCEPT {
   return true;
 }
 
 template <class GC_T1, class GC_T2>
-inline bool operator!=(const gc_allocator_ignore_off_page<GC_T1>&,
-                       const gc_allocator_ignore_off_page<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator!=(const gc_allocator_ignore_off_page<GC_T1>&,
+                const gc_allocator_ignore_off_page<GC_T2>&) GC_NOEXCEPT {
   return false;
 }
 
@@ -282,34 +288,41 @@ class traceable_allocator {
     typedef traceable_allocator<GC_Tp1> other;
   };
 
-  traceable_allocator() GC_NOEXCEPT {}
-  traceable_allocator(const traceable_allocator&) GC_NOEXCEPT {}
+  GC_CONSTEXPR traceable_allocator() GC_NOEXCEPT {}
+  GC_CONSTEXPR traceable_allocator(const traceable_allocator&) GC_NOEXCEPT {}
 # ifndef GC_NO_MEMBER_TEMPLATES
     template <class GC_Tp1> GC_ATTR_EXPLICIT
-    traceable_allocator(const traceable_allocator<GC_Tp1>&) GC_NOEXCEPT {}
+    GC_CONSTEXPR traceable_allocator(
+                const traceable_allocator<GC_Tp1>&) GC_NOEXCEPT {}
 # endif
-  ~traceable_allocator() GC_NOEXCEPT {}
+  GC_CONSTEXPR ~traceable_allocator() GC_NOEXCEPT {}
 
-  pointer address(reference GC_x) const { return &GC_x; }
-  const_pointer address(const_reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR pointer address(reference GC_x) const { return &GC_x; }
+  GC_CONSTEXPR const_pointer address(const_reference GC_x) const {
+    return &GC_x;
+  }
 
   // GC_n is permitted to be 0.  The C++ standard says nothing about what
   // the return value is when GC_n == 0.
-  GC_Tp* allocate(size_type GC_n, const void* = 0) {
+  GC_CONSTEXPR GC_Tp* allocate(size_type GC_n, const void* = 0) {
     void * obj = GC_MALLOC_UNCOLLECTABLE(GC_n * sizeof(GC_Tp));
     if (0 == obj)
       GC_ALLOCATOR_THROW_OR_ABORT();
     return static_cast<GC_Tp*>(obj);
   }
 
-  void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT
-    { GC_FREE(__p); }
+  GC_CONSTEXPR void deallocate(pointer __p, size_type /* GC_n */) GC_NOEXCEPT {
+    GC_FREE(__p);
+  }
 
-  size_type max_size() const GC_NOEXCEPT
+  GC_CONSTEXPR size_type max_size() const GC_NOEXCEPT
     { return size_t(-1) / sizeof(GC_Tp); }
 
-  void construct(pointer __p, const GC_Tp& __val) { new(__p) GC_Tp(__val); }
-  void destroy(pointer __p) { __p->~GC_Tp(); }
+  GC_CONSTEXPR void construct(pointer __p, const GC_Tp& __val) {
+    new(__p) GC_Tp(__val);
+  }
+
+  GC_CONSTEXPR void destroy(pointer __p) { __p->~GC_Tp(); }
 };
 
 template<>
@@ -328,16 +341,14 @@ class traceable_allocator<void> {
 
 
 template <class GC_T1, class GC_T2>
-inline bool operator==(const traceable_allocator<GC_T1>&,
-                       const traceable_allocator<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator==(const traceable_allocator<GC_T1>&,
+                const traceable_allocator<GC_T2>&) GC_NOEXCEPT {
   return true;
 }
 
 template <class GC_T1, class GC_T2>
-inline bool operator!=(const traceable_allocator<GC_T1>&,
-                       const traceable_allocator<GC_T2>&) GC_NOEXCEPT
-{
+GC_CONSTEXPR inline bool operator!=(const traceable_allocator<GC_T1>&,
+                const traceable_allocator<GC_T2>&) GC_NOEXCEPT {
   return false;
 }
 
diff --git a/include/gc_config_macros.h b/include/gc_config_macros.h
index afa839117..ec452c68d 100644
--- a/include/gc_config_macros.h
+++ b/include/gc_config_macros.h
@@ -453,6 +453,14 @@
 # endif
 #endif
 
+#ifndef GC_CONSTEXPR
+# if __cplusplus >= 202002L
+#   define GC_CONSTEXPR constexpr
+# else
+#   define GC_CONSTEXPR /* empty */
+# endif
+#endif
+
 #endif /* __cplusplus */
 
 #endif