libdispatch-913.30.4.tar.gz

[apple/libdispatch.git] / src / data_internal.h

diff --git a/src/data_internal.h b/src/data_internal.h
index d0de8bb9ce0e560bc297a2009d6c7c782837a022..19fc3d9adeb6d053650df50c6f36dc67baa95a19 100644 (file)
--- a/src/data_internal.h
+++ b/src/data_internal.h
@@ -32,60 +32,63 @@
 #include <dispatch/base.h> // for HeaderDoc
 #endif
 
-#if defined(__LP64__) && !defined(DISPATCH_DATA_USE_LEAF_MEMBER) && !USE_OBJC
-// explicit leaf member is free on 64bit due to padding
-#define DISPATCH_DATA_USE_LEAF_MEMBER 1
-#endif
-
 typedef struct range_record_s {
        dispatch_data_t data_object;
        size_t from;
        size_t length;
 } range_record;
 
-#if USE_OBJC
-#if OS_OBJECT_USE_OBJC
-@interface DISPATCH_CLASS(data) : NSObject <DISPATCH_CLASS(data)>
-@end
+#if OS_OBJECT_HAVE_OBJC2
+#define DISPATCH_DATA_IS_BRIDGED_TO_NSDATA 1
+#else
+#define DISPATCH_DATA_IS_BRIDGED_TO_NSDATA 0
 #endif
+
+#if DISPATCH_DATA_IS_BRIDGED_TO_NSDATA
 DISPATCH_OBJC_CLASS_DECL(data);
 DISPATCH_OBJC_CLASS_DECL(data_empty);
-#define DISPATCH_DATA_CLASS DISPATCH_OBJC_CLASS(data)
-#define DISPATCH_DATA_EMPTY_CLASS DISPATCH_OBJC_CLASS(data_empty)
-#else // USE_OBJC
+_OS_OBJECT_DECL_PROTOCOL(dispatch_data, dispatch_object);
+#define DISPATCH_DATA_CLASS DISPATCH_VTABLE(data)
+#define DISPATCH_DATA_EMPTY_CLASS DISPATCH_VTABLE(data_empty)
+#else
 DISPATCH_CLASS_DECL(data);
 #define DISPATCH_DATA_CLASS DISPATCH_VTABLE(data)
-#define DISPATCH_DATA_EMPTY_CLASS DISPATCH_VTABLE(data)
-#endif // USE_OBJC
+#endif // DISPATCH_DATA_IS_BRIDGED_TO_NSDATA
 
 struct dispatch_data_s {
-#if USE_OBJC
+#if DISPATCH_DATA_IS_BRIDGED_TO_NSDATA
        const void *do_vtable;
        dispatch_queue_t do_targetq;
        void *ctxt;
        void *finalizer;
-#else // USE_OBJC
-       DISPATCH_STRUCT_HEADER(data);
-#endif // USE_OBJC
-#if DISPATCH_DATA_USE_LEAF_MEMBER
-       bool leaf;
-#endif
+#else
+       DISPATCH_OBJECT_HEADER(data);
+#endif // DISPATCH_DATA_IS_BRIDGED_TO_NSDATA
+       const void *buf;
        dispatch_block_t destructor;
        size_t size, num_records;
-       union {
-               const void* buf;
-               range_record records[0];
-       };
+       range_record records[0];
 };
 
-#if DISPATCH_DATA_USE_LEAF_MEMBER
-#define _dispatch_data_leaf(d) ((d)->leaf)
-#define _dispatch_data_num_records(d) ((d)->num_records)
-#else
-#define _dispatch_data_leaf(d) ((d)->num_records ? 0 : ((d)->size ? 1 : 0))
-#define _dispatch_data_num_records(d) \
-               (_dispatch_data_leaf(d) ? 1 : (d)->num_records)
-#endif // DISPATCH_DATA_USE_LEAF_MEMBER
+DISPATCH_ALWAYS_INLINE
+static inline bool
+_dispatch_data_leaf(struct dispatch_data_s *dd)
+{
+       return dd->num_records == 0;
+}
+
+/*
+ * This is about the number of records required to hold that dispatch data
+ * if it's not a leaf. Callers either want that value, or have to special
+ * case the case when the dispatch data *is* a leaf before (and that the actual
+ * embedded record count of that dispatch data is 0)
+ */
+DISPATCH_ALWAYS_INLINE
+static inline size_t
+_dispatch_data_num_records(struct dispatch_data_s *dd)
+{
+       return dd->num_records ?: 1;
+}
 
 typedef dispatch_data_t (*dispatch_transform_t)(dispatch_data_t data);
 
@@ -97,31 +100,52 @@ struct dispatch_data_format_type_s {
        dispatch_transform_t encode;
 };
 
-void dispatch_data_init(dispatch_data_t data, const void *buffer, size_t size,
-               dispatch_block_t destructor);
-void _dispatch_data_dispose(dispatch_data_t data);
+void _dispatch_data_init_with_bytes(dispatch_data_t data, const void *buffer,
+               size_t size, dispatch_block_t destructor);
+void _dispatch_data_dispose(dispatch_data_t data, bool *allow_free);
+void _dispatch_data_set_target_queue(struct dispatch_data_s *dd,
+               dispatch_queue_t tq);
 size_t _dispatch_data_debug(dispatch_data_t data, char* buf, size_t bufsiz);
-const dispatch_block_t _dispatch_data_destructor_inline;
-#define DISPATCH_DATA_DESTRUCTOR_INLINE (_dispatch_data_destructor_inline)
+const void* _dispatch_data_get_flattened_bytes(struct dispatch_data_s *dd);
 
-#if !__OBJC2__
+#if !defined(__cplusplus)
+extern const dispatch_block_t _dispatch_data_destructor_inline;
+#define DISPATCH_DATA_DESTRUCTOR_INLINE (_dispatch_data_destructor_inline)
 
+/*
+ * the out parameters are about seeing "through" trivial subranges
+ * so for something like this: dd = { subrange [ dd1, offset1 ] },
+ * this will return { dd1, offset + offset1 }
+ *
+ * If the dispatch object isn't a trivial subrange, it returns { dd, offset }
+ */
+DISPATCH_ALWAYS_INLINE
 static inline const void*
-_dispatch_data_map_direct(dispatch_data_t dd)
+_dispatch_data_map_direct(struct dispatch_data_s *dd, size_t offset,
+               struct dispatch_data_s **dd_out, size_t *from_out)
 {
-       size_t offset = 0;
-       if (slowpath(!dd->size)) {
-               return NULL;
-       }
+       const void *buffer = NULL;
+
+       dispatch_assert(dd->size);
        if (slowpath(!_dispatch_data_leaf(dd)) &&
-                       _dispatch_data_num_records(dd) == 1 &&
-                       _dispatch_data_leaf(dd->records[0].data_object)) {
-               offset = dd->records[0].from;
-               dd = dd->records[0].data_object;
+                       _dispatch_data_num_records(dd) == 1) {
+               offset += dd->records[0].from;
+               dd = (struct dispatch_data_s *)dd->records[0].data_object;
+       }
+
+       if (fastpath(_dispatch_data_leaf(dd))) {
+               buffer = dd->buf + offset;
+       } else {
+               buffer = os_atomic_load((void **)&dd->buf, relaxed);
+               if (buffer) {
+                       buffer += offset;
+               }
        }
-       return fastpath(_dispatch_data_leaf(dd)) ? (dd->buf + offset) : NULL;
+       if (dd_out) *dd_out = dd;
+       if (from_out) *from_out = offset;
+       return buffer;
 }
 
-#endif // !__OBJC2__
+#endif // !defined(__cplusplus)
 
 #endif // __DISPATCH_DATA_INTERNAL__