MLIR  20.0.0git
Support.h
Go to the documentation of this file.
1 //===-- mlir-c/Support.h - Helpers for C API to Core MLIR ---------*- C -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
4 // Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This header declares the auxiliary data structures used in C APIs to core
11 // MLIR functionality.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef MLIR_C_SUPPORT_H
16 #define MLIR_C_SUPPORT_H
17 
18 #include <stdbool.h>
19 #include <stddef.h>
20 #include <stdint.h>
21 
22 //===----------------------------------------------------------------------===//
23 // Visibility annotations.
24 // Use MLIR_CAPI_EXPORTED for exported functions.
25 //
26 // On Windows, if MLIR_CAPI_ENABLE_WINDOWS_DLL_DECLSPEC is defined, then
27 // __declspec(dllexport) and __declspec(dllimport) will be generated. This
28 // can only be enabled if actually building DLLs. It is generally, mutually
29 // exclusive with the use of other mechanisms for managing imports/exports
30 // (i.e. CMake's WINDOWS_EXPORT_ALL_SYMBOLS feature).
31 //===----------------------------------------------------------------------===//
32 
33 #if (defined(_WIN32) || defined(__CYGWIN__)) && \
34  !defined(MLIR_CAPI_ENABLE_WINDOWS_DLL_DECLSPEC)
35 // Visibility annotations disabled.
36 #define MLIR_CAPI_EXPORTED
37 #elif defined(_WIN32) || defined(__CYGWIN__)
38 // Windows visibility declarations.
39 #if MLIR_CAPI_BUILDING_LIBRARY
40 #define MLIR_CAPI_EXPORTED __declspec(dllexport)
41 #else
42 #define MLIR_CAPI_EXPORTED __declspec(dllimport)
43 #endif
44 #else
45 // Non-windows: use visibility attributes.
46 #define MLIR_CAPI_EXPORTED __attribute__((visibility("default")))
47 #endif
48 
49 #ifdef __cplusplus
50 extern "C" {
51 #endif
52 
53 #define DEFINE_C_API_STRUCT(name, storage) \
54  struct name { \
55  storage *ptr; \
56  }; \
57  typedef struct name name
58 
59 /// Re-export llvm::ThreadPool so as to avoid including the LLVM C API directly.
60 DEFINE_C_API_STRUCT(MlirLlvmThreadPool, void);
61 DEFINE_C_API_STRUCT(MlirTypeID, const void);
62 DEFINE_C_API_STRUCT(MlirTypeIDAllocator, void);
63 
64 #undef DEFINE_C_API_STRUCT
65 
66 //===----------------------------------------------------------------------===//
67 // MlirStringRef.
68 //===----------------------------------------------------------------------===//
69 
70 /// A pointer to a sized fragment of a string, not necessarily null-terminated.
71 /// Does not own the underlying string. This is equivalent to llvm::StringRef.
72 
73 struct MlirStringRef {
74  const char *data; ///< Pointer to the first symbol.
75  size_t length; ///< Length of the fragment.
76 };
77 typedef struct MlirStringRef MlirStringRef;
78 
79 /// Constructs a string reference from the pointer and length. The pointer need
80 /// not reference to a null-terminated string.
81 
82 inline static MlirStringRef mlirStringRefCreate(const char *str,
83  size_t length) {
84  MlirStringRef result;
85  result.data = str;
86  result.length = length;
87  return result;
88 }
89 
90 /// Constructs a string reference from a null-terminated C string. Prefer
91 /// mlirStringRefCreate if the length of the string is known.
93 mlirStringRefCreateFromCString(const char *str);
94 
95 /// Returns true if two string references are equal, false otherwise.
97  MlirStringRef other);
98 
99 /// A callback for returning string references.
100 ///
101 /// This function is called back by the functions that need to return a
102 /// reference to the portion of the string with the following arguments:
103 /// - an MlirStringRef representing the current portion of the string
104 /// - a pointer to user data forwarded from the printing call.
105 typedef void (*MlirStringCallback)(MlirStringRef, void *);
106 
107 //===----------------------------------------------------------------------===//
108 // MlirLogicalResult.
109 //===----------------------------------------------------------------------===//
110 
111 /// A logical result value, essentially a boolean with named states. LLVM
112 /// convention for using boolean values to designate success or failure of an
113 /// operation is a moving target, so MLIR opted for an explicit class.
114 /// Instances of MlirLogicalResult must only be inspected using the associated
115 /// functions.
117  int8_t value;
118 };
119 typedef struct MlirLogicalResult MlirLogicalResult;
120 
121 /// Checks if the given logical result represents a success.
123  return res.value != 0;
124 }
125 
126 /// Checks if the given logical result represents a failure.
128  return res.value == 0;
129 }
130 
131 /// Creates a logical result representing a success.
133  MlirLogicalResult res = {1};
134  return res;
135 }
136 
137 /// Creates a logical result representing a failure.
139  MlirLogicalResult res = {0};
140  return res;
141 }
142 
143 //===----------------------------------------------------------------------===//
144 // MlirLlvmThreadPool.
145 //===----------------------------------------------------------------------===//
146 
147 /// Create an LLVM thread pool. This is reexported here to avoid directly
148 /// pulling in the LLVM headers directly.
149 MLIR_CAPI_EXPORTED MlirLlvmThreadPool mlirLlvmThreadPoolCreate(void);
150 
151 /// Destroy an LLVM thread pool.
152 MLIR_CAPI_EXPORTED void mlirLlvmThreadPoolDestroy(MlirLlvmThreadPool pool);
153 
154 //===----------------------------------------------------------------------===//
155 // TypeID API.
156 //===----------------------------------------------------------------------===//
157 
158 /// `ptr` must be 8 byte aligned and unique to a type valid for the duration of
159 /// the returned type id's usage
160 MLIR_CAPI_EXPORTED MlirTypeID mlirTypeIDCreate(const void *ptr);
161 
162 /// Checks whether a type id is null.
163 static inline bool mlirTypeIDIsNull(MlirTypeID typeID) { return !typeID.ptr; }
164 
165 /// Checks if two type ids are equal.
166 MLIR_CAPI_EXPORTED bool mlirTypeIDEqual(MlirTypeID typeID1, MlirTypeID typeID2);
167 
168 /// Returns the hash value of the type id.
169 MLIR_CAPI_EXPORTED size_t mlirTypeIDHashValue(MlirTypeID typeID);
170 
171 //===----------------------------------------------------------------------===//
172 // TypeIDAllocator API.
173 //===----------------------------------------------------------------------===//
174 
175 /// Creates a type id allocator for dynamic type id creation
176 MLIR_CAPI_EXPORTED MlirTypeIDAllocator mlirTypeIDAllocatorCreate(void);
177 
178 /// Deallocates the allocator and all allocated type ids
180 mlirTypeIDAllocatorDestroy(MlirTypeIDAllocator allocator);
181 
182 /// Allocates a type id that is valid for the lifetime of the allocator
183 MLIR_CAPI_EXPORTED MlirTypeID
184 mlirTypeIDAllocatorAllocateTypeID(MlirTypeIDAllocator allocator);
185 
186 #ifdef __cplusplus
187 }
188 #endif
189 
190 #endif // MLIR_C_SUPPORT_H
MLIR_CAPI_EXPORTED MlirTypeID mlirTypeIDCreate(const void *ptr)
ptr must be 8 byte aligned and unique to a type valid for the duration of the returned type id's usag...
Definition: Support.cpp:38
MLIR_CAPI_EXPORTED void mlirTypeIDAllocatorDestroy(MlirTypeIDAllocator allocator)
Deallocates the allocator and all allocated type ids.
Definition: Support.cpp:63
MLIR_CAPI_EXPORTED bool mlirStringRefEqual(MlirStringRef string, MlirStringRef other)
Returns true if two string references are equal, false otherwise.
Definition: Support.cpp:19
static MlirStringRef mlirStringRefCreate(const char *str, size_t length)
Constructs a string reference from the pointer and length.
Definition: Support.h:82
static MlirLogicalResult mlirLogicalResultFailure(void)
Creates a logical result representing a failure.
Definition: Support.h:138
MLIR_CAPI_EXPORTED MlirTypeID mlirTypeIDAllocatorAllocateTypeID(MlirTypeIDAllocator allocator)
Allocates a type id that is valid for the lifetime of the allocator.
Definition: Support.cpp:67
#define DEFINE_C_API_STRUCT(name, storage)
Definition: Support.h:53
MLIR_CAPI_EXPORTED void mlirLlvmThreadPoolDestroy(MlirLlvmThreadPool pool)
Destroy an LLVM thread pool.
Definition: Support.cpp:31
MLIR_CAPI_EXPORTED MlirLlvmThreadPool mlirLlvmThreadPoolCreate(void)
Create an LLVM thread pool.
Definition: Support.cpp:27
MLIR_CAPI_EXPORTED size_t mlirTypeIDHashValue(MlirTypeID typeID)
Returns the hash value of the type id.
Definition: Support.cpp:51
static MlirLogicalResult mlirLogicalResultSuccess(void)
Creates a logical result representing a success.
Definition: Support.h:132
#define MLIR_CAPI_EXPORTED
Definition: Support.h:46
struct MlirStringRef MlirStringRef
Definition: Support.h:77
static bool mlirLogicalResultIsSuccess(MlirLogicalResult res)
Checks if the given logical result represents a success.
Definition: Support.h:122
static bool mlirLogicalResultIsFailure(MlirLogicalResult res)
Checks if the given logical result represents a failure.
Definition: Support.h:127
MLIR_CAPI_EXPORTED MlirTypeIDAllocator mlirTypeIDAllocatorCreate(void)
Creates a type id allocator for dynamic type id creation.
Definition: Support.cpp:59
static bool mlirTypeIDIsNull(MlirTypeID typeID)
Checks whether a type id is null.
Definition: Support.h:163
MLIR_CAPI_EXPORTED bool mlirTypeIDEqual(MlirTypeID typeID1, MlirTypeID typeID2)
Checks if two type ids are equal.
Definition: Support.cpp:47
void(* MlirStringCallback)(MlirStringRef, void *)
A callback for returning string references.
Definition: Support.h:105
MLIR_CAPI_EXPORTED MlirStringRef mlirStringRefCreateFromCString(const char *str)
Constructs a string reference from a null-terminated C string.
Definition: Support.cpp:15
A logical result value, essentially a boolean with named states.
Definition: Support.h:116
A pointer to a sized fragment of a string, not necessarily null-terminated.
Definition: Support.h:73
const char * data
Pointer to the first symbol.
Definition: Support.h:74
size_t length
Length of the fragment.
Definition: Support.h:75