C API: Export functions in Windows

Adds visibility attributes to function declarations so that the symbols are
visible in the shared library (tensorflow.dll) built on Windows.
Change: 153622880

1 files changed, 351 insertions, 286 deletions

diff --git a/tensorflow/c/c_api.h b/tensorflow/c/c_api.h
index 88438a3585..e2aeef0d88 100644
--- a/tensorflow/c/c_api.h
+++ b/tensorflow/c/c_api.h
@@ -64,6 +64,25 @@ limitations under the License.
 //   and the API just provides high level controls over the number of
 //   devices of each type.
 
+// Macro to control visibility of exported symbols in the shared library (.so,
+// .dylib, .dll).
+// This duplicates the TF_EXPORT macro definition in
+// tensorflow/core/platform/macros.h in order to keep this .h file independent
+// of any other includes.$a
+#ifdef SWIG
+#define TF_CAPI_EXPORT
+#else
+#if defined(COMPILER_MSVC)
+#ifdef TF_COMPILE_LIBRARY
+#define TF_CAPI_EXPORT __declspec(dllexport)
+#else
+#define TF_CAPI_EXPORT __declspec(dllimport)
+#endif  // TF_COMPILE_LIBRARY
+#else
+#define TF_CAPI_EXPORT __attribute__((visibility("default")))
+#endif  // COMPILER_MSVC
+#endif  // SWIG
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -71,7 +90,7 @@ extern "C" {
 // --------------------------------------------------------------------------
 // TF_Version returns a string describing version information of the
 // TensorFlow library. TensorFlow using semantic versioning.
-extern const char* TF_Version();
+TF_CAPI_EXPORT extern const char* TF_Version();
 
 // --------------------------------------------------------------------------
 // TF_DataType holds the type for a scalar value.  E.g., one slot in a tensor.
@@ -103,7 +122,7 @@ typedef enum {
 // TF_DataTypeSize returns the sizeof() for the underlying type corresponding
 // to the given TF_DataType enum value. Returns 0 for variable length types
 // (eg. TF_STRING) or on failure.
-extern size_t TF_DataTypeSize(TF_DataType dt);
+TF_CAPI_EXPORT extern size_t TF_DataTypeSize(TF_DataType dt);
 
 // --------------------------------------------------------------------------
 // TF_Code holds an error code.  The enum values here are identical to
@@ -134,23 +153,24 @@ typedef enum {
 typedef struct TF_Status TF_Status;
 
 // Return a new status object.
-extern TF_Status* TF_NewStatus();
+TF_CAPI_EXPORT extern TF_Status* TF_NewStatus();
 
 // Delete a previously created status object.
-extern void TF_DeleteStatus(TF_Status*);
+TF_CAPI_EXPORT extern void TF_DeleteStatus(TF_Status*);
 
 // Record <code, msg> in *s.  Any previous information is lost.
 // A common use is to clear a status: TF_SetStatus(s, TF_OK, "");
-extern void TF_SetStatus(TF_Status* s, TF_Code code, const char* msg);
+TF_CAPI_EXPORT extern void TF_SetStatus(TF_Status* s, TF_Code code,
+                                        const char* msg);
 
 // Return the code record in *s.
-extern TF_Code TF_GetCode(const TF_Status* s);
+TF_CAPI_EXPORT extern TF_Code TF_GetCode(const TF_Status* s);
 
 // Return a pointer to the (null-terminated) error message in *s.  The
 // return value points to memory that is only usable until the next
 // mutation to *s.  Always returns an empty string if TF_GetCode(s) is
 // TF_OK.
-extern const char* TF_Message(const TF_Status* s);
+TF_CAPI_EXPORT extern const char* TF_Message(const TF_Status* s);
 
 // --------------------------------------------------------------------------
 // TF_Buffer holds a pointer to a block of data and its associated length.
@@ -168,14 +188,15 @@ typedef struct TF_Buffer {
 
 // Makes a copy of the input and sets an appropriate deallocator.  Useful for
 // passing in read-only, input protobufs.
-extern TF_Buffer* TF_NewBufferFromString(const void* proto, size_t proto_len);
+TF_CAPI_EXPORT extern TF_Buffer* TF_NewBufferFromString(const void* proto,
+                                                        size_t proto_len);
 
 // Useful for passing *out* a protobuf.
-extern TF_Buffer* TF_NewBuffer();
+TF_CAPI_EXPORT extern TF_Buffer* TF_NewBuffer();
 
-extern void TF_DeleteBuffer(TF_Buffer*);
+TF_CAPI_EXPORT extern void TF_DeleteBuffer(TF_Buffer*);
 
-extern TF_Buffer TF_GetBuffer(TF_Buffer* buffer);
+TF_CAPI_EXPORT extern TF_Buffer TF_GetBuffer(TF_Buffer* buffer);
 
 // --------------------------------------------------------------------------
 // TF_Tensor holds a multi-dimensional array of elements of a single data type.
@@ -202,11 +223,10 @@ typedef struct TF_Tensor TF_Tensor;
 //      (*deallocator)(data, len, deallocator_arg)
 // Clients must provide a custom deallocator function so they can pass in
 // memory managed by something like numpy.
-extern TF_Tensor* TF_NewTensor(TF_DataType, const int64_t* dims, int num_dims,
-                               void* data, size_t len,
-                               void (*deallocator)(void* data, size_t len,
-                                                   void* arg),
-                               void* deallocator_arg);
+TF_CAPI_EXPORT extern TF_Tensor* TF_NewTensor(
+    TF_DataType, const int64_t* dims, int num_dims, void* data, size_t len,
+    void (*deallocator)(void* data, size_t len, void* arg),
+    void* deallocator_arg);
 
 // Allocate and return a new Tensor.
 //
@@ -217,31 +237,32 @@ extern TF_Tensor* TF_NewTensor(TF_DataType, const int64_t* dims, int num_dims,
 //
 // The caller must set the Tensor values by writing them to the pointer returned
 // by TF_TensorData with length TF_TensorByteSize.
-extern TF_Tensor* TF_AllocateTensor(TF_DataType, const int64_t* dims,
-                                    int num_dims, size_t len);
+TF_CAPI_EXPORT extern TF_Tensor* TF_AllocateTensor(TF_DataType,
+                                                   const int64_t* dims,
+                                                   int num_dims, size_t len);
 
 // Deletes `tensor` and returns a new TF_Tensor with the same content if
 // possible. Returns nullptr and leaves `tensor` untouched if not.
-extern TF_Tensor* TF_TensorMaybeMove(TF_Tensor* tensor);
+TF_CAPI_EXPORT extern TF_Tensor* TF_TensorMaybeMove(TF_Tensor* tensor);
 
 // Destroy a tensor.
-extern void TF_DeleteTensor(TF_Tensor*);
+TF_CAPI_EXPORT extern void TF_DeleteTensor(TF_Tensor*);
 
 // Return the type of a tensor element.
-extern TF_DataType TF_TensorType(const TF_Tensor*);
+TF_CAPI_EXPORT extern TF_DataType TF_TensorType(const TF_Tensor*);
 
 // Return the number of dimensions that the tensor has.
-extern int TF_NumDims(const TF_Tensor*);
+TF_CAPI_EXPORT extern int TF_NumDims(const TF_Tensor*);
 
 // Return the length of the tensor in the "dim_index" dimension.
 // REQUIRES: 0 <= dim_index < TF_NumDims(tensor)
-extern int64_t TF_Dim(const TF_Tensor* tensor, int dim_index);
+TF_CAPI_EXPORT extern int64_t TF_Dim(const TF_Tensor* tensor, int dim_index);
 
 // Return the size of the underlying data in bytes.
-extern size_t TF_TensorByteSize(const TF_Tensor*);
+TF_CAPI_EXPORT extern size_t TF_TensorByteSize(const TF_Tensor*);
 
 // Return a pointer to the underlying data buffer.
-extern void* TF_TensorData(const TF_Tensor*);
+TF_CAPI_EXPORT extern void* TF_TensorData(const TF_Tensor*);
 
 // --------------------------------------------------------------------------
 // Encode the string `src` (`src_len` bytes long) into `dst` in the format
@@ -251,8 +272,9 @@ extern void* TF_TensorData(const TF_Tensor*);
 //
 // On success returns the size in bytes of the encoded string.
 // Returns an error into `status` otherwise.
-extern size_t TF_StringEncode(const char* src, size_t src_len, char* dst,
-                              size_t dst_len, TF_Status* status);
+TF_CAPI_EXPORT extern size_t TF_StringEncode(const char* src, size_t src_len,
+                                             char* dst, size_t dst_len,
+                                             TF_Status* status);
 
 // Decode a string encoded using TF_StringEncode.
 //
@@ -262,19 +284,20 @@ extern size_t TF_StringEncode(const char* src, size_t src_len, char* dst,
 // `*dst` and `*dst_len` are undefined and an error is set in `status`.
 //
 // Does not read memory more than `src_len` bytes beyond `src`.
-extern size_t TF_StringDecode(const char* src, size_t src_len, const char** dst,
-                              size_t* dst_len, TF_Status* status);
+TF_CAPI_EXPORT extern size_t TF_StringDecode(const char* src, size_t src_len,
+                                             const char** dst, size_t* dst_len,
+                                             TF_Status* status);
 
 // Return the size in bytes required to encode a string `len` bytes long into a
 // TF_STRING tensor.
-extern size_t TF_StringEncodedSize(size_t len);
+TF_CAPI_EXPORT extern size_t TF_StringEncodedSize(size_t len);
 
 // --------------------------------------------------------------------------
 // TF_SessionOptions holds options that can be passed during session creation.
 typedef struct TF_SessionOptions TF_SessionOptions;
 
 // Return a new options object.
-extern TF_SessionOptions* TF_NewSessionOptions();
+TF_CAPI_EXPORT extern TF_SessionOptions* TF_NewSessionOptions();
 
 // Set the target in TF_SessionOptions.options.
 // target can be empty, a single entry, or a comma separated list of entries.
@@ -282,17 +305,19 @@ extern TF_SessionOptions* TF_NewSessionOptions();
 // "local"
 // ip:port
 // host:port
-extern void TF_SetTarget(TF_SessionOptions* options, const char* target);
+TF_CAPI_EXPORT extern void TF_SetTarget(TF_SessionOptions* options,
+                                        const char* target);
 
 // Set the config in TF_SessionOptions.options.
 // config should be a serialized tensorflow.ConfigProto proto.
 // If config was not parsed successfully as a ConfigProto, record the
 // error information in *status.
-extern void TF_SetConfig(TF_SessionOptions* options, const void* proto,
-                         size_t proto_len, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_SetConfig(TF_SessionOptions* options,
+                                        const void* proto, size_t proto_len,
+                                        TF_Status* status);
 
 // Destroy an options object.
-extern void TF_DeleteSessionOptions(TF_SessionOptions*);
+TF_CAPI_EXPORT extern void TF_DeleteSessionOptions(TF_SessionOptions*);
 
 // TODO(jeff,sanjay):
 // - export functions to set Config fields
@@ -305,11 +330,11 @@ extern void TF_DeleteSessionOptions(TF_SessionOptions*);
 typedef struct TF_Graph TF_Graph;
 
 // Return a new graph object.
-extern TF_Graph* TF_NewGraph();
+TF_CAPI_EXPORT extern TF_Graph* TF_NewGraph();
 
 // Destroy an options object.  Graph will be deleted once no more
 // TFSession's are referencing it.
-extern void TF_DeleteGraph(TF_Graph*);
+TF_CAPI_EXPORT extern void TF_DeleteGraph(TF_Graph*);
 
 // Operation being built. The underlying graph must outlive this.
 typedef struct TF_OperationDescription TF_OperationDescription;
@@ -347,9 +372,11 @@ typedef struct TF_Output {
 //   * `output` is not in `graph`.
 //   * An invalid shape is being set (e.g., the shape being set
 //     is incompatible with the existing shape).
-extern void TF_GraphSetTensorShape(TF_Graph* graph, TF_Output output,
-                                   const int64_t* dims, const int num_dims,
-                                   TF_Status* status);
+TF_CAPI_EXPORT extern void TF_GraphSetTensorShape(TF_Graph* graph,
+                                                  TF_Output output,
+                                                  const int64_t* dims,
+                                                  const int num_dims,
+                                                  TF_Status* status);
 
 // Returns the number of dimensions of the Tensor referenced by `output`
 // in `graph`.
@@ -358,8 +385,9 @@ extern void TF_GraphSetTensorShape(TF_Graph* graph, TF_Output output,
 //
 // Returns an error into `status` if:
 //   * `output` is not in `graph`.
-extern int TF_GraphGetTensorNumDims(TF_Graph* graph, TF_Output output,
-                                    TF_Status* status);
+TF_CAPI_EXPORT extern int TF_GraphGetTensorNumDims(TF_Graph* graph,
+                                                   TF_Output output,
+                                                   TF_Status* status);
 
 // Returns the shape of the Tensor referenced by `output` in `graph`
 // into `dims`. `dims` must be an array large enough to hold `num_dims`
@@ -373,20 +401,21 @@ extern int TF_GraphGetTensorNumDims(TF_Graph* graph, TF_Output output,
 // Returns an error into `status` if:
 //   * `output` is not in `graph`.
 //   * `num_dims` does not match the actual number of dimensions.
-extern void TF_GraphGetTensorShape(TF_Graph* graph, TF_Output output,
-                                   int64_t* dims, int num_dims,
-                                   TF_Status* status);
+TF_CAPI_EXPORT extern void TF_GraphGetTensorShape(TF_Graph* graph,
+                                                  TF_Output output,
+                                                  int64_t* dims, int num_dims,
+                                                  TF_Status* status);
 
 // Operation will only be added to *graph when TF_FinishOperation() is
 // called (assuming TF_FinishOperation() does not return an error).
 // *graph must not be deleted until after TF_FinishOperation() is
 // called.
-extern TF_OperationDescription* TF_NewOperation(TF_Graph* graph,
-                                                const char* op_type,
-                                                const char* oper_name);
+TF_CAPI_EXPORT extern TF_OperationDescription* TF_NewOperation(
+    TF_Graph* graph, const char* op_type, const char* oper_name);
 
 // Specify the device for `desc`.  Defaults to empty, meaning unconstrained.
-extern void TF_SetDevice(TF_OperationDescription* desc, const char* device);
+TF_CAPI_EXPORT extern void TF_SetDevice(TF_OperationDescription* desc,
+                                        const char* device);
 
 // The calls to TF_AddInput and TF_AddInputList must match (in number,
 // order, and type) the op declaration.  For example, the "Concat" op
@@ -409,101 +438,115 @@ extern void TF_SetDevice(TF_OperationDescription* desc, const char* device);
 //   TF_AddInputList(desc, values_inputs, 5);
 
 // For inputs that take a single tensor.
-extern void TF_AddInput(TF_OperationDescription* desc, TF_Output input);
+TF_CAPI_EXPORT extern void TF_AddInput(TF_OperationDescription* desc,
+                                       TF_Output input);
 
 // For inputs that take a list of tensors.
 // inputs must point to TF_Output[num_inputs].
-extern void TF_AddInputList(TF_OperationDescription* desc,
-                            const TF_Output* inputs, int num_inputs);
+TF_CAPI_EXPORT extern void TF_AddInputList(TF_OperationDescription* desc,
+                                           const TF_Output* inputs,
+                                           int num_inputs);
 
 // Call once per control input to `desc`.
-extern void TF_AddControlInput(TF_OperationDescription* desc,
-                               TF_Operation* input);
+TF_CAPI_EXPORT extern void TF_AddControlInput(TF_OperationDescription* desc,
+                                              TF_Operation* input);
 
 // Request that `desc` be co-located on the device where `op`
 // is placed.
 //
 // Use of this is discouraged since the implementation of device placement is
 // subject to change. Primarily intended for internal libraries
-extern void TF_ColocateWith(TF_OperationDescription* desc, TF_Operation* op);
+TF_CAPI_EXPORT extern void TF_ColocateWith(TF_OperationDescription* desc,
+                                           TF_Operation* op);
 
 // Call some TF_SetAttr*() function for every attr that is not
 // inferred from an input and doesn't have a default value you wish to
 // keep.
 
 // `value` must point to a string of length `length` bytes.
-extern void TF_SetAttrString(TF_OperationDescription* desc,
-                             const char* attr_name, const void* value,
-                             size_t length);
+TF_CAPI_EXPORT extern void TF_SetAttrString(TF_OperationDescription* desc,
+                                            const char* attr_name,
+                                            const void* value, size_t length);
 // `values` and `lengths` each must have lengths `num_values`.
 // `values[i]` must point to a string of length `lengths[i]` bytes.
-extern void TF_SetAttrStringList(TF_OperationDescription* desc,
-                                 const char* attr_name,
-                                 const void* const* values,
-                                 const size_t* lengths, int num_values);
-extern void TF_SetAttrInt(TF_OperationDescription* desc, const char* attr_name,
-                          int64_t value);
-extern void TF_SetAttrIntList(TF_OperationDescription* desc,
-                              const char* attr_name, const int64_t* values,
-                              int num_values);
-extern void TF_SetAttrFloat(TF_OperationDescription* desc,
-                            const char* attr_name, float value);
-extern void TF_SetAttrFloatList(TF_OperationDescription* desc,
-                                const char* attr_name, const float* values,
-                                int num_values);
-extern void TF_SetAttrBool(TF_OperationDescription* desc, const char* attr_name,
-                           unsigned char value);
-extern void TF_SetAttrBoolList(TF_OperationDescription* desc,
-                               const char* attr_name,
-                               const unsigned char* values, int num_values);
-extern void TF_SetAttrType(TF_OperationDescription* desc, const char* attr_name,
-                           TF_DataType value);
-extern void TF_SetAttrTypeList(TF_OperationDescription* desc,
-                               const char* attr_name, const TF_DataType* values,
-                               int num_values);
+TF_CAPI_EXPORT extern void TF_SetAttrStringList(TF_OperationDescription* desc,
+                                                const char* attr_name,
+                                                const void* const* values,
+                                                const size_t* lengths,
+                                                int num_values);
+TF_CAPI_EXPORT extern void TF_SetAttrInt(TF_OperationDescription* desc,
+                                         const char* attr_name, int64_t value);
+TF_CAPI_EXPORT extern void TF_SetAttrIntList(TF_OperationDescription* desc,
+                                             const char* attr_name,
+                                             const int64_t* values,
+                                             int num_values);
+TF_CAPI_EXPORT extern void TF_SetAttrFloat(TF_OperationDescription* desc,
+                                           const char* attr_name, float value);
+TF_CAPI_EXPORT extern void TF_SetAttrFloatList(TF_OperationDescription* desc,
+                                               const char* attr_name,
+                                               const float* values,
+                                               int num_values);
+TF_CAPI_EXPORT extern void TF_SetAttrBool(TF_OperationDescription* desc,
+                                          const char* attr_name,
+                                          unsigned char value);
+TF_CAPI_EXPORT extern void TF_SetAttrBoolList(TF_OperationDescription* desc,
+                                              const char* attr_name,
+                                              const unsigned char* values,
+                                              int num_values);
+TF_CAPI_EXPORT extern void TF_SetAttrType(TF_OperationDescription* desc,
+                                          const char* attr_name,
+                                          TF_DataType value);
+TF_CAPI_EXPORT extern void TF_SetAttrTypeList(TF_OperationDescription* desc,
+                                              const char* attr_name,
+                                              const TF_DataType* values,
+                                              int num_values);
 
 // Set `num_dims` to -1 to represent "unknown rank".  Otherwise,
 // `dims` points to an array of length `num_dims`.  `dims[i]` must be
 // >= -1, with -1 meaning "unknown dimension".
-extern void TF_SetAttrShape(TF_OperationDescription* desc,
-                            const char* attr_name, const int64_t* dims,
-                            int num_dims);
+TF_CAPI_EXPORT extern void TF_SetAttrShape(TF_OperationDescription* desc,
+                                           const char* attr_name,
+                                           const int64_t* dims, int num_dims);
 // `dims` and `num_dims` must point to arrays of length `num_shapes`.
 // Set `num_dims[i]` to -1 to represent "unknown rank".  Otherwise,
 // `dims[i]` points to an array of length `num_dims[i]`.  `dims[i][j]`
 // must be >= -1, with -1 meaning "unknown dimension".
-extern void TF_SetAttrShapeList(TF_OperationDescription* desc,
-                                const char* attr_name,
-                                const int64_t* const* dims, const int* num_dims,
-                                int num_shapes);
+TF_CAPI_EXPORT extern void TF_SetAttrShapeList(TF_OperationDescription* desc,
+                                               const char* attr_name,
+                                               const int64_t* const* dims,
+                                               const int* num_dims,
+                                               int num_shapes);
 // `proto` must point to an array of `proto_len` bytes representing a
 // binary-serialized TensorShapeProto.
-extern void TF_SetAttrTensorShapeProto(TF_OperationDescription* desc,
-                                       const char* attr_name, const void* proto,
-                                       size_t proto_len, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_SetAttrTensorShapeProto(
+    TF_OperationDescription* desc, const char* attr_name, const void* proto,
+    size_t proto_len, TF_Status* status);
 // `protos` and `proto_lens` must point to arrays of length `num_shapes`.
 // `protos[i]` must point to an array of `proto_lens[i]` bytes
 // representing a binary-serialized TensorShapeProto.
-extern void TF_SetAttrTensorShapeProtoList(TF_OperationDescription* desc,
-                                           const char* attr_name,
-                                           const void* const* protos,
-                                           const size_t* proto_lens,
-                                           int num_shapes, TF_Status* status);
-
-extern void TF_SetAttrTensor(TF_OperationDescription* desc,
-                             const char* attr_name, TF_Tensor* value,
-                             TF_Status* status);
-extern void TF_SetAttrTensorList(TF_OperationDescription* desc,
-                                 const char* attr_name,
-                                 TF_Tensor* const* values, int num_values,
-                                 TF_Status* status);
+TF_CAPI_EXPORT extern void TF_SetAttrTensorShapeProtoList(
+    TF_OperationDescription* desc, const char* attr_name,
+    const void* const* protos, const size_t* proto_lens, int num_shapes,
+    TF_Status* status);
+
+TF_CAPI_EXPORT extern void TF_SetAttrTensor(TF_OperationDescription* desc,
+                                            const char* attr_name,
+                                            TF_Tensor* value,
+                                            TF_Status* status);
+TF_CAPI_EXPORT extern void TF_SetAttrTensorList(TF_OperationDescription* desc,
+                                                const char* attr_name,
+                                                TF_Tensor* const* values,
+                                                int num_values,
+                                                TF_Status* status);
 
 // `proto` should point to a sequence of bytes of length `proto_len`
 // representing a binary serialization of an AttrValue protocol
 // buffer.
-extern void TF_SetAttrValueProto(TF_OperationDescription* desc,
-                                 const char* attr_name, const void* proto,
-                                 size_t proto_len, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_SetAttrValueProto(TF_OperationDescription* desc,
+                                                const char* attr_name,
+                                                const void* proto,
+                                                size_t proto_len,
+                                                TF_Status* status);
 
 // If this function succeeds:
 //   * *status is set to an OK value,
@@ -515,37 +558,38 @@ extern void TF_SetAttrValueProto(TF_OperationDescription* desc,
 //   * the graph is not modified,
 //   * a null value is returned.
 // In either case, it deletes `desc`.
-extern TF_Operation* TF_FinishOperation(TF_OperationDescription* desc,
-                                        TF_Status* status);
+TF_CAPI_EXPORT extern TF_Operation* TF_FinishOperation(
+    TF_OperationDescription* desc, TF_Status* status);
 
 // TF_Operation functions.  Operations are immutable once created, so
 // these are all query functions.
 
-extern const char* TF_OperationName(TF_Operation* oper);
-extern const char* TF_OperationOpType(TF_Operation* oper);
-extern const char* TF_OperationDevice(TF_Operation* oper);
+TF_CAPI_EXPORT extern const char* TF_OperationName(TF_Operation* oper);
+TF_CAPI_EXPORT extern const char* TF_OperationOpType(TF_Operation* oper);
+TF_CAPI_EXPORT extern const char* TF_OperationDevice(TF_Operation* oper);
 
-extern int TF_OperationNumOutputs(TF_Operation* oper);
-extern TF_DataType TF_OperationOutputType(TF_Output oper_out);
-extern int TF_OperationOutputListLength(TF_Operation* oper,
-                                        const char* arg_name,
-                                        TF_Status* status);
+TF_CAPI_EXPORT extern int TF_OperationNumOutputs(TF_Operation* oper);
+TF_CAPI_EXPORT extern TF_DataType TF_OperationOutputType(TF_Output oper_out);
+TF_CAPI_EXPORT extern int TF_OperationOutputListLength(TF_Operation* oper,
+                                                       const char* arg_name,
+                                                       TF_Status* status);
 
-extern int TF_OperationNumInputs(TF_Operation* oper);
-extern TF_DataType TF_OperationInputType(TF_Input oper_in);
-extern int TF_OperationInputListLength(TF_Operation* oper, const char* arg_name,
-                                       TF_Status* status);
+TF_CAPI_EXPORT extern int TF_OperationNumInputs(TF_Operation* oper);
+TF_CAPI_EXPORT extern TF_DataType TF_OperationInputType(TF_Input oper_in);
+TF_CAPI_EXPORT extern int TF_OperationInputListLength(TF_Operation* oper,
+                                                      const char* arg_name,
+                                                      TF_Status* status);
 
 // In this code:
 //   TF_Output producer = TF_OperationInput(consumer);
 // There is an edge from producer.oper's output (given by
 // producer.index) to consumer.oper's input (given by consumer.index).
-extern TF_Output TF_OperationInput(TF_Input oper_in);
+TF_CAPI_EXPORT extern TF_Output TF_OperationInput(TF_Input oper_in);
 
 // Get the number of current consumers of a specific output of an
 // operation.  Note that this number can change when new operations
 // are added to the graph.
-extern int TF_OperationOutputNumConsumers(TF_Output oper_out);
+TF_CAPI_EXPORT extern int TF_OperationOutputNumConsumers(TF_Output oper_out);
 
 // Get list of all current consumers of a specific output of an
 // operation.  `consumers` must point to an array of length at least
@@ -554,24 +598,24 @@ extern int TF_OperationOutputNumConsumers(TF_Output oper_out);
 // modification of the graph can increase the number of consumers of
 // an operation.  Returns the number of output consumers (should match
 // TF_OperationOutputNumConsumers(oper_out)).
-extern int TF_OperationOutputConsumers(TF_Output oper_out, TF_Input* consumers,
-                                       int max_consumers);
+TF_CAPI_EXPORT extern int TF_OperationOutputConsumers(TF_Output oper_out,
+                                                      TF_Input* consumers,
+                                                      int max_consumers);
 
 // Get the number of control inputs to an operation.
-extern int TF_OperationNumControlInputs(TF_Operation* oper);
+TF_CAPI_EXPORT extern int TF_OperationNumControlInputs(TF_Operation* oper);
 
 // Get list of all control inputs to an operation.  `control_inputs` must
 // point to an array of length `max_control_inputs` (ideally set to
 // TF_OperationNumControlInputs(oper)).  Returns the number of control
 // inputs (should match TF_OperationNumControlInputs(oper)).
-extern int TF_OperationGetControlInputs(TF_Operation* oper,
-                                        TF_Operation** control_inputs,
-                                        int max_control_inputs);
+TF_CAPI_EXPORT extern int TF_OperationGetControlInputs(
+    TF_Operation* oper, TF_Operation** control_inputs, int max_control_inputs);
 
 // Get the number of operations that have `*oper` as a control input.
 // Note that this number can change when new operations are added to
 // the graph.
-extern int TF_OperationNumControlOutputs(TF_Operation* oper);
+TF_CAPI_EXPORT extern int TF_OperationNumControlOutputs(TF_Operation* oper);
 
 // Get the list of operations that have `*oper` as a control input.
 // `control_outputs` must point to an array of length at least
@@ -580,9 +624,9 @@ extern int TF_OperationNumControlOutputs(TF_Operation* oper);
 // modification of the graph can increase the number of control
 // outputs.  Returns the number of control outputs (should match
 // TF_OperationNumControlOutputs(oper)).
-extern int TF_OperationGetControlOutputs(TF_Operation* oper,
-                                         TF_Operation** control_outputs,
-                                         int max_control_outputs);
+TF_CAPI_EXPORT extern int TF_OperationGetControlOutputs(
+    TF_Operation* oper, TF_Operation** control_outputs,
+    int max_control_outputs);
 
 // TF_AttrType describes the type of the value of an attribute on an operation.
 typedef enum {
@@ -629,17 +673,18 @@ typedef struct TF_AttrMetadata {
 } TF_AttrMetadata;
 
 // Returns metadata about the value of the attribute `attr_name` of `oper`.
-extern TF_AttrMetadata TF_OperationGetAttrMetadata(TF_Operation* oper,
-                                                   const char* attr_name,
-                                                   TF_Status* status);
+TF_CAPI_EXPORT extern TF_AttrMetadata TF_OperationGetAttrMetadata(
+    TF_Operation* oper, const char* attr_name, TF_Status* status);
 
 // Fills in `value` with the value of the attribute `attr_name`.  `value` must
 // point to an array of length at least `max_length` (ideally set to
 // TF_AttrMetadata.total_size from TF_OperationGetAttrMetadata(oper,
 // attr_name)).
-extern void TF_OperationGetAttrString(TF_Operation* oper, const char* attr_name,
-                                      void* value, size_t max_length,
-                                      TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrString(TF_Operation* oper,
+                                                     const char* attr_name,
+                                                     void* value,
+                                                     size_t max_length,
+                                                     TF_Status* status);
 
 // Get the list of strings in the value of the attribute `attr_name`.  Fills in
 // `values` and `lengths`, each of which must point to an array of length at
@@ -652,64 +697,78 @@ extern void TF_OperationGetAttrString(TF_Operation* oper, const char* attr_name,
 // attr_name).
 //
 // Fails if storage_size is too small to hold the requested number of strings.
-extern void TF_OperationGetAttrStringList(TF_Operation* oper,
-                                          const char* attr_name, void** values,
-                                          size_t* lengths, int max_values,
-                                          void* storage, size_t storage_size,
-                                          TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrStringList(
+    TF_Operation* oper, const char* attr_name, void** values, size_t* lengths,
+    int max_values, void* storage, size_t storage_size, TF_Status* status);
 
-extern void TF_OperationGetAttrInt(TF_Operation* oper, const char* attr_name,
-                                   int64_t* value, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrInt(TF_Operation* oper,
+                                                  const char* attr_name,
+                                                  int64_t* value,
+                                                  TF_Status* status);
 
 // Fills in `values` with the value of the attribute `attr_name` of `oper`.
 // `values` must point to an array of length at least `max_values` (ideally set
 // TF_AttrMetadata.list_size from TF_OperationGetAttrMetadata(oper,
 // attr_name)).
-extern void TF_OperationGetAttrIntList(TF_Operation* oper,
-                                       const char* attr_name, int64_t* values,
-                                       int max_values, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrIntList(TF_Operation* oper,
+                                                      const char* attr_name,
+                                                      int64_t* values,
+                                                      int max_values,
+                                                      TF_Status* status);
 
-extern void TF_OperationGetAttrFloat(TF_Operation* oper, const char* attr_name,
-                                     float* value, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrFloat(TF_Operation* oper,
+                                                    const char* attr_name,
+                                                    float* value,
+                                                    TF_Status* status);
 
 // Fills in `values` with the value of the attribute `attr_name` of `oper`.
 // `values` must point to an array of length at least `max_values` (ideally set
 // to TF_AttrMetadata.list_size from TF_OperationGetAttrMetadata(oper,
 // attr_name)).
-extern void TF_OperationGetAttrFloatList(TF_Operation* oper,
-                                         const char* attr_name, float* values,
-                                         int max_values, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrFloatList(TF_Operation* oper,
+                                                        const char* attr_name,
+                                                        float* values,
+                                                        int max_values,
+                                                        TF_Status* status);
 
-extern void TF_OperationGetAttrBool(TF_Operation* oper, const char* attr_name,
-                                    unsigned char* value, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrBool(TF_Operation* oper,
+                                                   const char* attr_name,
+                                                   unsigned char* value,
+                                                   TF_Status* status);
 
 // Fills in `values` with the value of the attribute `attr_name` of `oper`.
 // `values` must point to an array of length at least `max_values` (ideally set
 // to TF_AttrMetadata.list_size from TF_OperationGetAttrMetadata(oper,
 // attr_name)).
-extern void TF_OperationGetAttrBoolList(TF_Operation* oper,
-                                        const char* attr_name,
-                                        unsigned char* values, int max_values,
-                                        TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrBoolList(TF_Operation* oper,
+                                                       const char* attr_name,
+                                                       unsigned char* values,
+                                                       int max_values,
+                                                       TF_Status* status);
 
-extern void TF_OperationGetAttrType(TF_Operation* oper, const char* attr_name,
-                                    TF_DataType* value, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrType(TF_Operation* oper,
+                                                   const char* attr_name,
+                                                   TF_DataType* value,
+                                                   TF_Status* status);
 
 // Fills in `values` with the value of the attribute `attr_name` of `oper`.
 // `values` must point to an array of length at least `max_values` (ideally set
 // to TF_AttrMetadata.list_size from TF_OperationGetAttrMetadata(oper,
 // attr_name)).
-extern void TF_OperationGetAttrTypeList(TF_Operation* oper,
-                                        const char* attr_name,
-                                        TF_DataType* values, int max_values,
-                                        TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrTypeList(TF_Operation* oper,
+                                                       const char* attr_name,
+                                                       TF_DataType* values,
+                                                       int max_values,
+                                                       TF_Status* status);
 
 // Fills in `value` with the value of the attribute `attr_name` of `oper`.
 // `values` must point to an array of length at least `num_dims` (ideally set to
 // TF_Attr_Meta.size from TF_OperationGetAttrMetadata(oper, attr_name)).
-extern void TF_OperationGetAttrShape(TF_Operation* oper, const char* attr_name,
-                                     int64_t* value, int num_dims,
-                                     TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrShape(TF_Operation* oper,
+                                                    const char* attr_name,
+                                                    int64_t* value,
+                                                    int num_dims,
+                                                    TF_Status* status);
 
 // Fills in `dims` with the list of shapes in the attribute `attr_name` of
 // `oper` and `num_dims` with the corresponding number of dimensions. On return,
@@ -724,35 +783,32 @@ extern void TF_OperationGetAttrShape(TF_Operation* oper, const char* attr_name,
 // attr_name).
 //
 // Fails if storage_size is insufficient to hold the requested shapes.
-extern void TF_OperationGetAttrShapeList(TF_Operation* oper,
-                                         const char* attr_name, int64_t** dims,
-                                         int* num_dims, int num_shapes,
-                                         int64_t* storage, int storage_size,
-                                         TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrShapeList(
+    TF_Operation* oper, const char* attr_name, int64_t** dims, int* num_dims,
+    int num_shapes, int64_t* storage, int storage_size, TF_Status* status);
 
 // Sets `value` to the binary-serialized TensorShapeProto of the value of
 // `attr_name` attribute of `oper`'.
-extern void TF_OperationGetAttrTensorShapeProto(TF_Operation* oper,
-                                                const char* attr_name,
-                                                TF_Buffer* value,
-                                                TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrTensorShapeProto(
+    TF_Operation* oper, const char* attr_name, TF_Buffer* value,
+    TF_Status* status);
 
 // Fills in `values` with binary-serialized TensorShapeProto values of the
 // attribute `attr_name` of `oper`. `values` must point to an array of length at
 // least `num_values` (ideally set to TF_AttrMetadata.list_size from
 // TF_OperationGetAttrMetadata(oper, attr_name)).
-extern void TF_OperationGetAttrTensorShapeProtoList(TF_Operation* oper,
-                                                    const char* attr_name,
-                                                    TF_Buffer** values,
-                                                    int max_values,
-                                                    TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrTensorShapeProtoList(
+    TF_Operation* oper, const char* attr_name, TF_Buffer** values,
+    int max_values, TF_Status* status);
 
 // Gets the TF_Tensor valued attribute of `attr_name` of `oper`.
 //
 // Allocates a new TF_Tensor which the caller is expected to take
 // ownership of (and can deallocate using TF_DeleteTensor).
-extern void TF_OperationGetAttrTensor(TF_Operation* oper, const char* attr_name,
-                                      TF_Tensor** value, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrTensor(TF_Operation* oper,
+                                                     const char* attr_name,
+                                                     TF_Tensor** value,
+                                                     TF_Status* status);
 
 // Fills in `values` with the TF_Tensor values of the attribute `attr_name` of
 // `oper`. `values` must point to an array of TF_Tensor* of length at least
@@ -761,22 +817,22 @@ extern void TF_OperationGetAttrTensor(TF_Operation* oper, const char* attr_name,
 //
 // The caller takes ownership of all the non-null TF_Tensor* entries in `values`
 // (which can be deleted using TF_DeleteTensor(values[i])).
-extern void TF_OperationGetAttrTensorList(TF_Operation* oper,
-                                          const char* attr_name,
-                                          TF_Tensor** values, int max_values,
-                                          TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrTensorList(TF_Operation* oper,
+                                                         const char* attr_name,
+                                                         TF_Tensor** values,
+                                                         int max_values,
+                                                         TF_Status* status);
 
 // Sets `output_attr_value` to the binary-serialized AttrValue proto
 // representation of the value of the `attr_name` attr of `oper`.
-extern void TF_OperationGetAttrValueProto(TF_Operation* oper,
-                                          const char* attr_name,
-                                          TF_Buffer* output_attr_value,
-                                          TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationGetAttrValueProto(
+    TF_Operation* oper, const char* attr_name, TF_Buffer* output_attr_value,
+    TF_Status* status);
 
 // Returns the operation in the graph with `oper_name`. Returns nullptr if
 // no operation found.
-extern TF_Operation* TF_GraphOperationByName(TF_Graph* graph,
-                                             const char* oper_name);
+TF_CAPI_EXPORT extern TF_Operation* TF_GraphOperationByName(
+    TF_Graph* graph, const char* oper_name);
 
 // Iterate through the operations of a graph.  To use:
 // size_t pos = 0;
@@ -784,7 +840,8 @@ extern TF_Operation* TF_GraphOperationByName(TF_Graph* graph,
 // while ((oper = TF_GraphNextOperation(graph, &pos)) != nullptr) {
 //   DoSomethingWithOperation(oper);
 // }
-extern TF_Operation* TF_GraphNextOperation(TF_Graph* graph, size_t* pos);
+TF_CAPI_EXPORT extern TF_Operation* TF_GraphNextOperation(TF_Graph* graph,
+                                                          size_t* pos);
 
 // Write out a serialized representation of `graph` (as a GraphDef protocol
 // message) to `output_graph_def` (allocated by TF_NewBuffer()).
@@ -792,25 +849,27 @@ extern TF_Operation* TF_GraphNextOperation(TF_Graph* graph, size_t* pos);
 // is called.
 //
 // May fail on very large graphs in the future.
-extern void TF_GraphToGraphDef(TF_Graph* graph, TF_Buffer* output_graph_def,
-                               TF_Status* status);
+TF_CAPI_EXPORT extern void TF_GraphToGraphDef(TF_Graph* graph,
+                                              TF_Buffer* output_graph_def,
+                                              TF_Status* status);
 
 // TF_ImportGraphDefOptions holds options that can be passed to
 // TF_GraphImportGraphDef.
 typedef struct TF_ImportGraphDefOptions TF_ImportGraphDefOptions;
 
-extern TF_ImportGraphDefOptions* TF_NewImportGraphDefOptions();
-extern void TF_DeleteImportGraphDefOptions(TF_ImportGraphDefOptions* opts);
+TF_CAPI_EXPORT extern TF_ImportGraphDefOptions* TF_NewImportGraphDefOptions();
+TF_CAPI_EXPORT extern void TF_DeleteImportGraphDefOptions(
+    TF_ImportGraphDefOptions* opts);
 
 // Set the prefix to be prepended to the names of nodes in `graph_def` that will
 // be imported into `graph`.
-extern void TF_ImportGraphDefOptionsSetPrefix(TF_ImportGraphDefOptions* opts,
-                                              const char* prefix);
+TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsSetPrefix(
+    TF_ImportGraphDefOptions* opts, const char* prefix);
 
 // Set any imported nodes with input `src_name:src_index` to have that input
 // replaced with `dst`. `src_name` refers to a node in the graph to be imported,
 // `dst` references a node already existing in the graph being imported into.
-extern void TF_ImportGraphDefOptionsAddInputMapping(
+TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsAddInputMapping(
     TF_ImportGraphDefOptions* opts, const char* src_name, int src_index,
     TF_Output dst);
 
@@ -818,23 +877,23 @@ extern void TF_ImportGraphDefOptionsAddInputMapping(
 // replaced with `dst`. `src_name` refers to a node in the graph to be imported,
 // `dst` references an operation already existing in the graph being imported
 // into.
-extern void TF_ImportGraphDefOptionsRemapControlDependency(
+TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsRemapControlDependency(
     TF_ImportGraphDefOptions* opts, const char* src_name, TF_Operation* dst);
 
 // Cause the imported graph to have a control dependency on `oper`. `oper`
 // should exist in the graph being imported into.
-extern void TF_ImportGraphDefOptionsAddControlDependency(
+TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsAddControlDependency(
     TF_ImportGraphDefOptions* opts, TF_Operation* oper);
 
 // Add an output in `graph_def` to be returned via the `return_outputs` output
 // parameter of TF_GraphImportGraphDef(). If the output is remapped via an input
 // mapping, the corresponding existing tensor in `graph` will be returned.
-extern void TF_ImportGraphDefOptionsAddReturnOutput(
+TF_CAPI_EXPORT extern void TF_ImportGraphDefOptionsAddReturnOutput(
     TF_ImportGraphDefOptions* opts, const char* oper_name, int index);
 
 // Returns the number of return outputs added via
 // TF_ImportGraphDefOptionsAddReturnOutput().
-extern int TF_ImportGraphDefOptionsNumReturnOutputs(
+TF_CAPI_EXPORT extern int TF_ImportGraphDefOptionsNumReturnOutputs(
     const TF_ImportGraphDefOptions* opts);
 
 // Import the graph serialized in `graph_def` into `graph`.
@@ -843,22 +902,22 @@ extern int TF_ImportGraphDefOptionsNumReturnOutputs(
 // result of TF_ImportGraphDefOptionsNumReturnOutputs()).  If
 // `num_return_outputs` is non-zero, `return_outputs` must be of length
 // `num_return_outputs`. Otherwise it can be null.
-extern void TF_GraphImportGraphDefWithReturnOutputs(
+TF_CAPI_EXPORT extern void TF_GraphImportGraphDefWithReturnOutputs(
     TF_Graph* graph, const TF_Buffer* graph_def,
     const TF_ImportGraphDefOptions* options, TF_Output* return_outputs,
     int num_return_outputs, TF_Status* status);
 
 // Import the graph serialized in `graph_def` into `graph`.
 // Convenience function for when no return outputs have been added.
-extern void TF_GraphImportGraphDef(TF_Graph* graph, const TF_Buffer* graph_def,
-                                   const TF_ImportGraphDefOptions* options,
-                                   TF_Status* status);
+TF_CAPI_EXPORT extern void TF_GraphImportGraphDef(
+    TF_Graph* graph, const TF_Buffer* graph_def,
+    const TF_ImportGraphDefOptions* options, TF_Status* status);
 
 // Note: The following function may fail on very large protos in the future.
 
-extern void TF_OperationToNodeDef(TF_Operation* oper,
-                                  TF_Buffer* output_node_def,
-                                  TF_Status* status);
+TF_CAPI_EXPORT extern void TF_OperationToNodeDef(TF_Operation* oper,
+                                                 TF_Buffer* output_node_def,
+                                                 TF_Status* status);
 
 typedef struct TF_WhileParams {
   // The number of inputs to the while loop, i.e. the number of loop variables.
@@ -955,8 +1014,9 @@ typedef struct TF_Session TF_Session;
 // *graph must be a valid graph (not deleted or nullptr).  This function will
 // prevent the graph from being deleted until TF_DeleteSession() is called.
 // Does not take ownership of opts.
-extern TF_Session* TF_NewSession(TF_Graph* graph, const TF_SessionOptions* opts,
-                                 TF_Status* status);
+TF_CAPI_EXPORT extern TF_Session* TF_NewSession(TF_Graph* graph,
+                                                const TF_SessionOptions* opts,
+                                                TF_Status* status);
 
 // This function creates a new TF_Session (which is created on success) using
 // `session_options`, and then initializes state (restoring tensors and other
@@ -981,7 +1041,7 @@ TF_Session* TF_LoadSessionFromSavedModel(
 //
 // Contacts any other processes associated with the session, if applicable.
 // May not be called after TF_DeleteSession().
-extern void TF_CloseSession(TF_Session*, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_CloseSession(TF_Session*, TF_Status* status);
 
 // Destroy a session object.
 //
@@ -989,7 +1049,7 @@ extern void TF_CloseSession(TF_Session*, TF_Status* status);
 // local resources associated with the session.  The session may not be used
 // during or after this call (and the session drops its reference to the
 // corresponding graph).
-extern void TF_DeleteSession(TF_Session*, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_DeleteSession(TF_Session*, TF_Status* status);
 
 // Run the graph associated with the session starting with the supplied inputs
 // (inputs[0,ninputs-1] with corresponding values in input_values[0,ninputs-1]).
@@ -1015,21 +1075,20 @@ extern void TF_DeleteSession(TF_Session*, TF_Status* status);
 // to the caller, which must eventually call TF_DeleteTensor on them.
 //
 // On failure, output_values[] contains NULLs.
-extern void TF_SessionRun(TF_Session* session,
-                          // RunOptions
-                          const TF_Buffer* run_options,
-                          // Input tensors
-                          const TF_Output* inputs,
-                          TF_Tensor* const* input_values, int ninputs,
-                          // Output tensors
-                          const TF_Output* outputs, TF_Tensor** output_values,
-                          int noutputs,
-                          // Target operations
-                          const TF_Operation* const* target_opers, int ntargets,
-                          // RunMetadata
-                          TF_Buffer* run_metadata,
-                          // Output status
-                          TF_Status*);
+TF_CAPI_EXPORT extern void TF_SessionRun(
+    TF_Session* session,
+    // RunOptions
+    const TF_Buffer* run_options,
+    // Input tensors
+    const TF_Output* inputs, TF_Tensor* const* input_values, int ninputs,
+    // Output tensors
+    const TF_Output* outputs, TF_Tensor** output_values, int noutputs,
+    // Target operations
+    const TF_Operation* const* target_opers, int ntargets,
+    // RunMetadata
+    TF_Buffer* run_metadata,
+    // Output status
+    TF_Status*);
 
 // Set up the graph with the intended feeds (inputs) and fetches (outputs) for a
 // sequence of partial run calls.
@@ -1041,38 +1100,36 @@ extern void TF_SessionRun(TF_Session* session,
 // On failure, out_status contains a tensorflow::Status with an error
 // message.
 // NOTE: This is EXPERIMENTAL and subject to change.
-extern void TF_SessionPRunSetup(TF_Session*,
-                                // Input names
-                                const TF_Output* inputs, int ninputs,
-                                // Output names
-                                const TF_Output* outputs, int noutputs,
-                                // Target operations
-                                const TF_Operation* const* target_opers,
-                                int ntargets,
-                                // Output handle
-                                const char** handle,
-                                // Output status
-                                TF_Status*);
+TF_CAPI_EXPORT extern void TF_SessionPRunSetup(
+    TF_Session*,
+    // Input names
+    const TF_Output* inputs, int ninputs,
+    // Output names
+    const TF_Output* outputs, int noutputs,
+    // Target operations
+    const TF_Operation* const* target_opers, int ntargets,
+    // Output handle
+    const char** handle,
+    // Output status
+    TF_Status*);
 
 // Continue to run the graph with additional feeds and fetches. The
 // execution state is uniquely identified by the handle.
 // NOTE: This is EXPERIMENTAL and subject to change.
-extern void TF_SessionPRun(TF_Session*, const char* handle,
-                           // Input tensors
-                           const TF_Output* inputs,
-                           TF_Tensor* const* input_values, int ninputs,
-                           // Output tensors
-                           const TF_Output* outputs, TF_Tensor** output_values,
-                           int noutputs,
-                           // Target operations
-                           const TF_Operation* const* target_opers,
-                           int ntargets,
-                           // Output status
-                           TF_Status*);
+TF_CAPI_EXPORT extern void TF_SessionPRun(
+    TF_Session*, const char* handle,
+    // Input tensors
+    const TF_Output* inputs, TF_Tensor* const* input_values, int ninputs,
+    // Output tensors
+    const TF_Output* outputs, TF_Tensor** output_values, int noutputs,
+    // Target operations
+    const TF_Operation* const* target_opers, int ntargets,
+    // Output status
+    TF_Status*);
 
 // Deletes a handle allocated by TF_SessionPRunSetup.
 // Once called, no more calls to TF_SessionPRun should be made.
-extern void TF_DeletePRunHandle(const char* handle);
+TF_CAPI_EXPORT extern void TF_DeletePRunHandle(const char* handle);
 
 // --------------------------------------------------------------------------
 // The deprecated session API.  Please switch to the above instead of
@@ -1081,39 +1138,47 @@ extern void TF_DeletePRunHandle(const char* handle);
 
 typedef struct TF_DeprecatedSession TF_DeprecatedSession;
 
-extern TF_DeprecatedSession* TF_NewDeprecatedSession(const TF_SessionOptions*,
+TF_CAPI_EXPORT extern TF_DeprecatedSession* TF_NewDeprecatedSession(
+    const TF_SessionOptions*, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_CloseDeprecatedSession(TF_DeprecatedSession*,
                                                      TF_Status* status);
-extern void TF_CloseDeprecatedSession(TF_DeprecatedSession*, TF_Status* status);
-extern void TF_DeleteDeprecatedSession(TF_DeprecatedSession*,
-                                       TF_Status* status);
-extern void TF_Reset(const TF_SessionOptions* opt, const char** containers,
-                     int ncontainers, TF_Status* status);
+TF_CAPI_EXPORT extern void TF_DeleteDeprecatedSession(TF_DeprecatedSession*,
+                                                      TF_Status* status);
+TF_CAPI_EXPORT extern void TF_Reset(const TF_SessionOptions* opt,
+                                    const char** containers, int ncontainers,
+                                    TF_Status* status);
 // Treat the bytes proto[0,proto_len-1] as a serialized GraphDef and
 // add the nodes in that GraphDef to the graph for the session.
 //
 // Prefer use of TF_Session and TF_GraphImportGraphDef over this.
-extern void TF_ExtendGraph(TF_DeprecatedSession*, const void* proto,
-                           size_t proto_len, TF_Status*);
+TF_CAPI_EXPORT extern void TF_ExtendGraph(TF_DeprecatedSession*,
+                                          const void* proto, size_t proto_len,
+                                          TF_Status*);
 
 // See TF_SessionRun() above.
-extern void TF_Run(TF_DeprecatedSession*, const TF_Buffer* run_options,
-                   const char** input_names, TF_Tensor** inputs, int ninputs,
-                   const char** output_names, TF_Tensor** outputs, int noutputs,
-                   const char** target_oper_names, int ntargets,
-                   TF_Buffer* run_metadata, TF_Status*);
+TF_CAPI_EXPORT extern void TF_Run(TF_DeprecatedSession*,
+                                  const TF_Buffer* run_options,
+                                  const char** input_names, TF_Tensor** inputs,
+                                  int ninputs, const char** output_names,
+                                  TF_Tensor** outputs, int noutputs,
+                                  const char** target_oper_names, int ntargets,
+                                  TF_Buffer* run_metadata, TF_Status*);
 
 // See TF_SessionPRunSetup() above.
-extern void TF_PRunSetup(TF_DeprecatedSession*, const char** input_names,
-                         int ninputs, const char** output_names, int noutputs,
-                         const char** target_oper_names, int ntargets,
-                         const char** handle, TF_Status*);
+TF_CAPI_EXPORT extern void TF_PRunSetup(TF_DeprecatedSession*,
+                                        const char** input_names, int ninputs,
+                                        const char** output_names, int noutputs,
+                                        const char** target_oper_names,
+                                        int ntargets, const char** handle,
+                                        TF_Status*);
 
 // See TF_SessionPRun above.
-extern void TF_PRun(TF_DeprecatedSession*, const char* handle,
-                    const char** input_names, TF_Tensor** inputs, int ninputs,
-                    const char** output_names, TF_Tensor** outputs,
-                    int noutputs, const char** target_oper_names, int ntargets,
-                    TF_Status*);
+TF_CAPI_EXPORT extern void TF_PRun(TF_DeprecatedSession*, const char* handle,
+                                   const char** input_names, TF_Tensor** inputs,
+                                   int ninputs, const char** output_names,
+                                   TF_Tensor** outputs, int noutputs,
+                                   const char** target_oper_names, int ntargets,
+                                   TF_Status*);
 
 // --------------------------------------------------------------------------
 // Load plugins containing custom ops and kernels
@@ -1132,19 +1197,19 @@ typedef struct TF_Library TF_Library;
 // The caller owns the library handle.
 //
 // On failure, place an error status in status and return NULL.
-extern TF_Library* TF_LoadLibrary(const char* library_filename,
-                                  TF_Status* status);
+TF_CAPI_EXPORT extern TF_Library* TF_LoadLibrary(const char* library_filename,
+                                                 TF_Status* status);
 
 // Get the OpList of OpDefs defined in the library pointed by lib_handle.
 //
 // Returns a TF_Buffer. The memory pointed to by the result is owned by
 // lib_handle. The data in the buffer will be the serialized OpList proto for
 // ops defined in the library.
-extern TF_Buffer TF_GetOpList(TF_Library* lib_handle);
+TF_CAPI_EXPORT extern TF_Buffer TF_GetOpList(TF_Library* lib_handle);
 
 // Frees the memory associated with the library handle.
 // Does NOT unload the library.
-extern void TF_DeleteLibraryHandle(TF_Library* lib_handle);
+TF_CAPI_EXPORT extern void TF_DeleteLibraryHandle(TF_Library* lib_handle);
 
 // Get the OpList of all OpDefs defined in this address space.
 // Returns a TF_Buffer, ownership of which is transferred to the caller
@@ -1152,7 +1217,7 @@ extern void TF_DeleteLibraryHandle(TF_Library* lib_handle);
 //
 // The data in the buffer will be the serialized OpList proto for ops registered
 // in this address space.
-extern TF_Buffer* TF_GetAllOpList();
+TF_CAPI_EXPORT extern TF_Buffer* TF_GetAllOpList();
 
 #ifdef __cplusplus
 } /* end extern "C" */