[atomic] Templatize

src/hb-atomic.hh

@@ -149,64 +149,49 @@ static inline void _hb_compiler_memory_r_barrier () {}
 #define hb_atomic_ptr_impl_get_relaxed(P)	(*(P))
 #endif
 #ifndef hb_atomic_int_impl_set
-inline void hb_atomic_int_impl_set (int *AI, int v)	{ _hb_memory_w_barrier (); *AI = v; }
-inline void hb_atomic_int_impl_set (short *AI, short v)	{ _hb_memory_w_barrier (); *AI = v; }
+template <typename T>
+inline void hb_atomic_int_impl_set (T *AI, T v)	{ _hb_memory_w_barrier (); *AI = v; }
 #endif
 #ifndef hb_atomic_int_impl_get
-inline int hb_atomic_int_impl_get (const int *AI)	{ int v = *AI; _hb_memory_r_barrier (); return v; }
-inline short hb_atomic_int_impl_get (const short *AI)	{ short v = *AI; _hb_memory_r_barrier (); return v; }
+template <typename T>
+inline T hb_atomic_int_impl_get (const T *AI)	{ T v = *AI; _hb_memory_r_barrier (); return v; }
 #endif
 #ifndef hb_atomic_ptr_impl_get
 inline void *hb_atomic_ptr_impl_get (void ** const P)	{ void *v = *P; _hb_memory_r_barrier (); return v; }
 #endif
 
 
-struct hb_atomic_short_t
+template <typename T>
+struct hb_atomic_t
 {
-  hb_atomic_short_t () = default;
-  constexpr hb_atomic_short_t (short v) : v (v) {}
+  hb_atomic_t () = default;
+  constexpr hb_atomic_t (T v) : v (v) {}
 
-  hb_atomic_short_t& operator = (short v_) { set_relaxed (v_); return *this; }
-  operator short () const { return get_relaxed (); }
+  hb_atomic_t& operator = (T v_) { set_relaxed (v_); return *this; }
+  operator T () const { return get_relaxed (); }
 
-  void set_relaxed (short v_) { hb_atomic_int_impl_set_relaxed (&v, v_); }
-  void set_release (short v_) { hb_atomic_int_impl_set (&v, v_); }
-  short get_relaxed () const { return hb_atomic_int_impl_get_relaxed (&v); }
-  short get_acquire () const { return hb_atomic_int_impl_get (&v); }
-  short inc () { return hb_atomic_int_impl_add (&v,  1); }
-  short dec () { return hb_atomic_int_impl_add (&v, -1); }
+  void set_relaxed (T v_) { hb_atomic_int_impl_set_relaxed (&v, v_); }
+  void set_release (T v_) { hb_atomic_int_impl_set (&v, v_); }
+  T get_relaxed () const { return hb_atomic_int_impl_get_relaxed (&v); }
+  T get_acquire () const { return hb_atomic_int_impl_get (&v); }
+  T inc () { return hb_atomic_int_impl_add (&v,  1); }
+  T dec () { return hb_atomic_int_impl_add (&v, -1); }
 
-  short v = 0;
-};
-
-struct hb_atomic_int_t
-{
-  hb_atomic_int_t () = default;
-  constexpr hb_atomic_int_t (int v) : v (v) {}
-
-  hb_atomic_int_t& operator = (int v_) { set_relaxed (v_); return *this; }
-  operator int () const { return get_relaxed (); }
   int operator ++ (int) { return inc (); }
   int operator -- (int) { return dec (); }
+  long operator |= (long v_) { set_relaxed (get_relaxed () | v_); return *this; }
 
-  void set_relaxed (int v_) { hb_atomic_int_impl_set_relaxed (&v, v_); }
-  void set_release (int v_) { hb_atomic_int_impl_set (&v, v_); }
-  int get_relaxed () const { return hb_atomic_int_impl_get_relaxed (&v); }
-  int get_acquire () const { return hb_atomic_int_impl_get (&v); }
-  int inc () { return hb_atomic_int_impl_add (&v,  1); }
-  int dec () { return hb_atomic_int_impl_add (&v, -1); }
-
-  int v = 0;
+  T v = 0;
 };
 
 template <typename P>
-struct hb_atomic_ptr_t
+struct hb_atomic_t<P*>
 {
   typedef hb_remove_pointer<P> T;
 
-  hb_atomic_ptr_t () = default;
-  constexpr hb_atomic_ptr_t (T* v) : v (v) {}
-  hb_atomic_ptr_t (const hb_atomic_ptr_t &other) = delete;
+  hb_atomic_t () = default;
+  constexpr hb_atomic_t (T* v) : v (v) {}
+  hb_atomic_t (const hb_atomic_t &other) = delete;
 
   void init (T* v_ = nullptr) { set_relaxed (v_); }
   void set_relaxed (T* v_) { hb_atomic_ptr_impl_set_relaxed (&v, v_); }
@@ -220,6 +205,8 @@ struct hb_atomic_ptr_t
 
   T *v = nullptr;
 };
+template <typename T>
+using hb_atomic_ptr_t = hb_atomic_t<T*>;
 
 static inline bool hb_barrier ()
 {

src/hb-bit-set.hh

@@ -77,7 +77,7 @@ struct hb_bit_set_t
 
   bool successful = true; /* Allocations successful */
   mutable unsigned int population = 0;
-  mutable hb_atomic_int_t last_page_lookup = 0;
+  mutable hb_atomic_t<unsigned> last_page_lookup = 0;
   hb_sorted_vector_t<page_map_t> page_map;
   hb_vector_t<page_t> pages;
 

src/hb-cache.hh

@@ -52,11 +52,11 @@ struct hb_cache_t
 {
   using item_t = typename std::conditional<thread_safe,
 					   typename std::conditional<key_bits + value_bits - cache_bits <= 16,
-								     hb_atomic_short_t,
-								     hb_atomic_int_t>::type,
+								     hb_atomic_t<unsigned short>,
+								     hb_atomic_t<unsigned int>>::type,
 					   typename std::conditional<key_bits + value_bits - cache_bits <= 16,
-								     short,
-								     int>::type
+								     unsigned short,
+								     unsigned int>::type
 					  >::type;
 
   static_assert ((key_bits >= cache_bits), "");

src/hb-common.cc

@@ -42,7 +42,7 @@
 
 /* hb_options_t */
 
-hb_atomic_int_t _hb_options;
+hb_atomic_t<unsigned> _hb_options;
 
 void
 _hb_options_init ()

src/hb-debug.hh

@@ -49,15 +49,15 @@ struct hb_options_t
 };
 
 union hb_options_union_t {
-  int i;
+  unsigned i;
   hb_options_t opts;
 };
-static_assert ((sizeof (hb_atomic_int_t) >= sizeof (hb_options_union_t)), "");
+static_assert ((sizeof (hb_atomic_t<unsigned>) >= sizeof (hb_options_union_t)), "");
 
 HB_INTERNAL void
 _hb_options_init ();
 
-extern HB_INTERNAL hb_atomic_int_t _hb_options;
+extern HB_INTERNAL hb_atomic_t<unsigned> _hb_options;
 
 static inline hb_options_t
 hb_options ()

src/hb-face.hh

@@ -49,8 +49,8 @@ struct hb_face_t
   hb_object_header_t header;
 
   unsigned int index;			/* Face index in a collection, zero-based. */
-  mutable hb_atomic_int_t upem;		/* Units-per-EM. */
-  mutable hb_atomic_int_t num_glyphs;	/* Number of glyphs. */
+  mutable hb_atomic_t<unsigned> upem;	/* Units-per-EM. */
+  mutable hb_atomic_t<unsigned> num_glyphs;/* Number of glyphs. */
 
   hb_reference_table_func_t  reference_table_func;
   void                      *user_data;

src/hb-font.hh

@@ -106,8 +106,8 @@ DECLARE_NULL_INSTANCE (hb_font_funcs_t);
 struct hb_font_t
 {
   hb_object_header_t header;
-  hb_atomic_int_t serial;
-  hb_atomic_int_t serial_coords;
+  hb_atomic_t<unsigned> serial;
+  hb_atomic_t<unsigned> serial_coords;
 
   hb_font_t *parent;
   hb_face_t *face;

src/hb-ft.cc

@@ -101,7 +101,7 @@ struct hb_ft_font_t
 
   mutable hb_mutex_t lock; /* Protects members below. */
   FT_Face ft_face;
-  mutable hb_atomic_int_t cached_serial;
+  mutable hb_atomic_t<unsigned> cached_serial;
   mutable hb_ft_advance_cache_t advance_cache;
 };
 
@@ -118,7 +118,7 @@ _hb_ft_font_create (FT_Face ft_face, bool symbol, bool unref)
 
   ft_font->load_flags = FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING;
 
-  ft_font->cached_serial = -1;
+  ft_font->cached_serial = UINT_MAX;
   new (&ft_font->advance_cache) hb_ft_advance_cache_t;
 
   return ft_font;

src/hb-object.hh

@@ -142,7 +142,7 @@ struct hb_lockable_set_t
 
 struct hb_reference_count_t
 {
-  mutable hb_atomic_int_t ref_count;
+  mutable hb_atomic_t<int> ref_count;
 
   void init (int v = 1) { ref_count = v; }
   int get_relaxed () const { return ref_count; }
@@ -213,7 +213,7 @@ struct hb_user_data_array_t
 struct hb_object_header_t
 {
   hb_reference_count_t ref_count;
-  mutable hb_atomic_int_t writable = 0;
+  mutable hb_atomic_t<bool> writable = false;
   hb_atomic_ptr_t<hb_user_data_array_t> user_data;
 
   bool is_inert () const { return !ref_count.get_relaxed (); }

src/hb-ot-font.cc

@@ -85,7 +85,7 @@ struct hb_ot_font_t
 #endif
 
   /* h_advance caching */
-  mutable hb_atomic_int_t cached_coords_serial;
+  mutable hb_atomic_t<int> cached_coords_serial;
   mutable hb_atomic_ptr_t<hb_ot_font_advance_cache_t> advance_cache;
 };
 

src/hb-ot-shaper-indic.cc

@@ -301,7 +301,7 @@ struct indic_shape_plan_t
 #else
   static constexpr bool uniscribe_bug_compatible = false;
 #endif
-  mutable hb_atomic_int_t virama_glyph;
+  mutable hb_atomic_t<hb_codepoint_t> virama_glyph;
 
   hb_indic_would_substitute_feature_t rphf;
   hb_indic_would_substitute_feature_t pref;

src/hb-ot-tag.cc

@@ -326,7 +326,7 @@ hb_ot_tags_from_language (const char   *lang_str,
 
     hb_tag_t lang_tag = hb_tag_from_string (lang_str, first_len);
 
-    static hb_atomic_int_t last_tag_idx; /* Poor man's cache. */
+    static hb_atomic_t<unsigned> last_tag_idx = 0; /* Poor man's cache. */
     unsigned tag_idx = last_tag_idx;
 
     if (likely (tag_idx < ot_languages_len && ot_languages[tag_idx].language == lang_tag) ||