Cuda Wrapper for Wine Partially completed just having compiling errors

The source code can be found here , or below. I’m updating the wrapper we use for folding at home, and for some reason I am getting some undefined reference errors. I have correctly linked -lcudart , so I’m not sure what I am missing. Any help would be greatly appreciated.

s.shelnutt@funtoo-64 ~/gpu3/wrapper/cudart $ make

winegcc -c  -mno-cygwin -I/usr/local/cuda/include/   -o cudart.o cudart.c

In file included from /usr/local/cuda/include/cuda_runtime_api.h:53,

				 from /usr/local/cuda/include/crt/host_runtime.h:108,

				 from cudart.c:7:

/usr/local/cuda/include/host_defines.h:57:1: warning: "__cdecl" redefined

<command-line>: warning: this is the location of the previous definition

In file included from cudart.c:8:

/usr/local/cuda/include/device_functions.h: In function '__sinf':

/usr/local/cuda/include/device_functions.h:4437: warning: incompatible implicit declaration of built-in function 'sinf'

/usr/local/cuda/include/device_functions.h: In function '__cosf':

/usr/local/cuda/include/device_functions.h:4447: warning: incompatible implicit declaration of built-in function 'cosf'

/usr/local/cuda/include/device_functions.h: In function '__log2f':

/usr/local/cuda/include/device_functions.h:4452: warning: incompatible implicit declaration of built-in function 'log2f'

cudart.c: In function 'wine_cudaGetTextureReference':

cudart.c:296: warning: passing argument 1 of 'cudaGetTextureReference' from incompatible pointer type

/usr/local/cuda/include/cuda_runtime_api.h:189: note: expected 'const struct textureReference **' but argument is of type 'struct textureReference **'

cudart.c: In function 'wine_cudaRegisterFatBinary':

cudart.c:549: warning: return makes pointer from integer without a cast

cudart.c: In function 'wine_cudaUnregisterFatBinary':

cudart.c:553: warning: 'return' with a value, in function returning void

cudart.c: In function 'wine_cudaRegisterVar':

cudart.c:557: warning: 'return' with a value, in function returning void

cudart.c: In function 'wine_cudaRegisterTexture':

cudart.c:561: warning: 'return' with a value, in function returning void

cudart.c: In function 'wine_cudaRegisterShared':

cudart.c:565: warning: 'return' with a value, in function returning void

cudart.c: In function 'wine_cudaRegisterSharedVar':

cudart.c:569: warning: 'return' with a value, in function returning void

cudart.c: In function 'wine_cudaRegisterFunction':

cudart.c:574: warning: 'return' with a value, in function returning void

cudart.c: At top level:

/usr/local/cuda/include/device_functions.h:3768: warning: '__cuda___isnan' used but never defined

/usr/local/cuda/include/device_functions.h:3769: warning: '__cuda___isnanf' used but never defined

winegcc -shared cudart.dll.spec -mno-cygwin -o cudart.dll.so cudart.o	-L/usr/local/cuda/lib/ -lcudart   -lodbc32 -lole32 -loleaut32 -lwinspool -lodbccp32 -luuid

cudart.o: In function `__saturatef':

cudart.c:(.text+0x3b6c): undefined reference to `__cuda___isnanf'

cudart.o: In function `__sad':

cudart.c:(.text+0x3bfc): undefined reference to `__cuda_llabs'

cudart.o: In function `__usad':

cudart.c:(.text+0x3c47): undefined reference to `__cuda_llabs'

cudart.o: In function `__internal_float2ll_kernel':

cudart.c:(.text+0x3d2b): undefined reference to `__cuda___isnanf'

cudart.o: In function `__internal_float2ull_kernel':

cudart.c:(.text+0x4082): undefined reference to `__cuda___isnanf'

cudart.o: In function `__fdividef':

cudart.c:(.text+0x4eaa): undefined reference to `__cuda_fabsf'

cudart.c:(.text+0x4ecf): undefined reference to `__cuda_fabsf'

cudart.o: In function `__expf':

cudart.c:(.text+0x5085): undefined reference to `__cuda_exp2f'

cudart.o: In function `__exp10f':

cudart.c:(.text+0x50b6): undefined reference to `__cuda_exp2f'

cudart.o: In function `__powf':

cudart.c:(.text+0x5140): undefined reference to `__cuda_exp2f'

cudart.o: In function `__internal_double2ll_kernel':

cudart.c:(.text+0x6130): undefined reference to `__cuda___isnan'

cudart.o: In function `__internal_double2ull_kernel':

cudart.c:(.text+0x6383): undefined reference to `__cuda___isnan'

cudart.o: In function `clock64':

cudart.c:(.text+0x7f61): undefined reference to `__cuda_clock'

/usr/lib/gcc/x86_64-pc-linux-gnu/4.4.3/../../../../x86_64-pc-linux-gnu/bin/ld: warning: creating a DT_TEXTREL in object.

collect2: ld returned 1 exit status

winegcc: x86_64-pc-linux-gnu-gcc failed

make: *** [cudart.dll.so] Error 2

s.shelnutt@funtoo-64 ~/gpu3/wrapper/cudart $

cudart.c

/*This is a wrapper for cudart32_30_14.dll and libcudart.so.3.0.14

 Copyrighted by Seth Shelnutt under the LGPL v2.1 or later

 */

#include <windows.h>

#include "crt/host_runtime.h"

#include "device_functions.h"

#include "sm_20_atomic_functions.h"

#include "texture_fetch_functions.h"

#include "cuda_runtime_api.h"

#include "cuda_gl_interop.h"

#include "driver_functions.h"

#include "driver_types.h"

//#include "math_functions.h"

#include <stdlib.h>

#include <GL/gl.h>

#include <string.h>

#include "wine/debug.h"

/*	#if 0

	#define __CUDA_INTERNAL_COMPILATION__

	#include "crt/host_runtime.h"

	#endif

	#ifdef USE_SLEEPWAIT

	#include <time.h>

	static struct timespec sleepTime = { 0, USE_SLEEPWAIT };

	#endif  /* USE_SLEEPWAIT */ 

WINE_DEFAULT_DEBUG_CHANNEL(cuda);

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaMalloc3D( struct cudaPitchedPtr* pitchDevPtr, struct cudaExtent extent ){

	return cudaMalloc3D( pitchDevPtr, extent );

}

cudaError_t WINAPI wine_cudaMalloc3DArray( struct cudaArray** arrayPtr, const struct cudaChannelFormatDesc* desc, struct cudaExtent extent ){

	return cudaMalloc3DArray( arrayPtr, desc, extent );

}

cudaError_t WINAPI wine_cudaMemset3D( struct cudaPitchedPtr pitchedDevPtr, int value, struct cudaExtent extent ){

	return cudaMemset3D( pitchedDevPtr, value, extent );

}

cudaError_t WINAPI wine_cudaMemcpy3D( const struct cudaMemcpy3DParms *p ){

	return cudaMemcpy3D( p );

}

cudaError_t WINAPI wine_cudaMemcpy3DAsync( const struct cudaMemcpy3DParms *p, cudaStream_t stream ){

	return cudaMemcpy3DAsync( p, stream );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaMalloc(void **devPtr, size_t size) {

		return cudaMalloc(devPtr, size);

	}

cudaError_t WINAPI wine_cudaMallocHost( void** hostPtr, size_t size ){

	return cudaMallocHost( hostPtr, size);

}

cudaError_t WINAPI wine_cudaMallocPitch( void** devPtr, size_t* pitch, size_t widthInBytes, size_t height ){

	return cudaMallocPitch( devPtr, pitch, widthInBytes, height );

}

cudaError_t WINAPI wine_cudaMallocArray( struct cudaArray** array, const struct cudaChannelFormatDesc* desc, size_t width, size_t height ){

	return cudaMallocArray( array, desc, width, height);

}

cudaError_t WINAPI wine_cudaFree(void *devPtr) {

		return cudaFree(devPtr);

}

cudaError_t WINAPI wine_cudaFreeHost( void* hostPtr ){

	return cudaFreeHost( hostPtr);

}

cudaError_t WINAPI wine_cudaFreeArray( struct cudaArray* array ){

	return cudaFreeArray( array );

}

cudaError_t WINAPI wine_cudaHostAlloc(void **pHost, size_t bytes, unsigned int flags){

	return cudaHostAlloc( pHost, bytes, flags );

}

cudaError_t WINAPI wine_cudaHostGetDevicePointer(void **pDevice, void *pHost, unsigned int flags){

	return cudaHostGetDevicePointer( pDevice, pHost, flags );

}

cudaError_t WINAPI wine_cudaHostGetFlags(unsigned int *pFlags, void *pHost){

	return cudaHostGetFlags( pFlags, pHost );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaMemGetInfo(size_t *free, size_t *total){

	return cudaMemGetInfo( free, total );

}

cudaError_t WINAPI wine_cudaMemcpy(void *dst, const void *src, size_t count, enum cudaMemcpyKind kind) {

		return cudaMemcpy(dst, src, count, kind);

}

cudaError_t WINAPI wine_cudaMemcpyToArray( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind ){

	return cudaMemcpyToArray( dst, wOffset, hOffset, src, count, kind );

}

cudaError_t WINAPI wine_cudaMemcpyFromArray( void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind ){

	return cudaMemcpyFromArray( dst, src, wOffset, hOffset, count, kind );

}

cudaError_t WINAPI wine_cudaMemcpyArrayToArray( struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t count, enum cudaMemcpyKind kind ){

	return cudaMemcpyArrayToArray( dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, count, kind );

}

cudaError_t WINAPI wine_cudaMemcpy2D( void* dst, size_t dpitch, const void* src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ){

	return cudaMemcpy2D( dst, dpitch, src, spitch, width, height, kind );

}

cudaError_t WINAPI wine_cudaMemcpy2DToArray( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind ){

	return cudaMemcpy2DToArray( dst, wOffset, hOffset, src, spitch, width, height, kind );

}

cudaError_t WINAPI wine_cudaMemcpy2DFromArray( void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind ){

	return cudaMemcpy2DFromArray( dst, dpitch, src, wOffset, hOffset, width, height, kind );

}

cudaError_t WINAPI wine_cudaMemcpy2DArrayToArray( struct cudaArray *dst, size_t wOffsetDst, size_t hOffsetDst, const struct cudaArray *src, size_t wOffsetSrc, size_t hOffsetSrc, size_t width, size_t height, enum cudaMemcpyKind kind ){

	return cudaMemcpy2DArrayToArray( dst, wOffsetDst, hOffsetDst, src, wOffsetSrc, hOffsetSrc, width, height, kind );

}

cudaError_t WINAPI wine_cudaMemcpyToSymbol( const char *symbol, const void *src, size_t count, size_t offset , enum cudaMemcpyKind kind ) {

	return cudaMemcpyToSymbol( symbol, src, count, offset, kind);

}

cudaError_t WINAPI wine_cudaMemcpyFromSymbol( void *dst, const char *symbol, size_t count, size_t offset , enum cudaMemcpyKind kind ) {

	return cudaMemcpyFromSymbol( dst, symbol, count, offset, kind );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaMemcpyAsync( void *dst, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpyAsync( dst, src, count, kind, stream );

}

cudaError_t WINAPI wine_cudaMemcpyToArrayAsync( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpyToArrayAsync( dst, wOffset, hOffset, src, count, kind, stream );\

}

cudaError_t WINAPI wine_cudaMemcpyFromArrayAsync( void *dst, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t count, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpyFromArrayAsync( dst, src, wOffset, hOffset, count, kind, stream );

}

cudaError_t WINAPI wine_cudaMemcpy2DAsync( void *dst, size_t dpitch, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpy2DAsync( dst, dpitch, src, spitch, width, height, kind, stream );

}

cudaError_t WINAPI wine_cudaMemcpy2DToArrayAsync( struct cudaArray *dst, size_t wOffset, size_t hOffset, const void *src, size_t spitch, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpy2DToArrayAsync( dst, wOffset, hOffset, src, spitch, width, height, kind, stream );

}

cudaError_t WINAPI wine_cudaMemcpy2DFromArrayAsync( void *dst, size_t dpitch, const struct cudaArray *src, size_t wOffset, size_t hOffset, size_t width, size_t height, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpy2DFromArrayAsync( dst, dpitch, src, wOffset, hOffset, width, height, kind, stream );

}

/*cudaError_t WINAPI cudaMemcpyToSymbolAsync( const char *symbol, const void *src, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpyToSymbolAsync( symbol, src, count, offset, kind, stream );

}

cudaError_t WINAPI cudaMemcpyFromSymbolAsync( void *dst, const char *symbol, size_t count, size_t offset, enum cudaMemcpyKind kind, cudaStream_t stream ){

	return cudaMemcpyFromSymbolAsync( dst, symbol, count, offset, kind, stream);

}*/

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaMemset( void *devPtr, int value, size_t count ){

	return cudaMemset( devPtr, value, count );

}

cudaError_t WINAPI wine_cudaMemset2D( void *devPtr, size_t pitch, int value, size_t width, size_t height ){

	return cudaMemset2D( devPtr, pitch, value, width, height );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGetSymbolAddress( void **devPtr, const char *symbol ){

	return cudaGetSymbolAddress( devPtr, symbol );

}

cudaError_t WINAPI wine_cudaGetSymbolSize( size_t *size, const char *symbol ){

	return cudaGetSymbolSize( size, symbol );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGetDeviceCount( int* count ){

	return cudaGetDeviceCount( count );

}

cudaError_t WINAPI wine_cudaGetDeviceProperties(struct cudaDeviceProp *prop, int device) {

	return cudaGetDeviceProperties(prop, device);

}

cudaError_t WINAPI wine_cudaChooseDevice( int *device, const struct cudaDeviceProp *prop ){

	return cudaChooseDevice( device, prop );

}

cudaError_t WINAPI wine_cudaSetDevice( int device ) {

	return cudaSetDevice( device );

}

cudaError_t WINAPI wine_cudaGetDevice( int* device ){

	return cudaGetDevice( device );

}

/*cudaError_t WINAPI cudaSetValidDevices( int *device_arr, int len ){

	return cudaSetValidDevices( device_arr, len);

}

cudaError_t WINAPI cudaSetDeviceFlags( int flags ){

	return cudaSetDeviceFlags( flags );

}*/

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaBindTexture( size_t *offset, const struct textureReference *texref, const void *devPtr, const struct cudaChannelFormatDesc *desc, size_t size ){

	return cudaBindTexture( offset, texref, devPtr, desc, size );

}

/*cudaError_t WINAPI cudaBindTexture2D( size_t *offset,const struct textureReference *texref,const void *devPtr, const struct cudaChannelFormatDesc *desc,size_t width, size_t height, size_t pitch ){

	return cudaBindTexture2D( offset, texref, devPtr, desc, width, height, pitch );

}*/

cudaError_t WINAPI wine_cudaBindTextureToArray( const struct textureReference *texref, const struct cudaArray *array, const struct cudaChannelFormatDesc *desc ){

	return cudaBindTextureToArray( texref, array, desc );

}

cudaError_t WINAPI wine_cudaUnbindTexture( const struct textureReference *texRef ){

	return cudaUnbindTexture( texRef );

}

cudaError_t WINAPI wine_cudaGetTextureAlignmentOffset( size_t *offset, const struct textureReference *texRef ){

	return cudaGetTextureAlignmentOffset( offset, texRef );

}

cudaError_t WINAPI wine_cudaGetTextureReference( struct textureReference **texRef, const char* symbol){

	return cudaGetTextureReference( texRef, symbol );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGetChannelDesc( struct cudaChannelFormatDesc *desc, const struct cudaArray *array ){

	return cudaGetChannelDesc( desc, array );

}

struct cudaChannelFormatDesc WINAPI wine_cudaCreateChannelDesc(int x, int y, int z, int w, enum cudaChannelFormatKind f){

	return cudaCreateChannelDesc(x, y, z, w, f);

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGetLastError() {

	return cudaGetLastError();

}

const char* WINAPI wine_cudaGetErrorString(cudaError_t error) {

	return cudaGetErrorString(error);

	}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaConfigureCall( dim3 gridDim, dim3 blockDim, size_t sharedMem, cudaStream_t stream ) {

	return cudaConfigureCall( gridDim, blockDim, sharedMem, stream );

}

cudaError_t WINAPI wine_cudaSetupArgument( const void *arg, size_t size, size_t offset ){

	return cudaSetupArgument( arg, size, offset );

}

cudaError_t WINAPI wine_cudaFuncSetCacheConfig( const char *func, enum cudaFuncCache cacheConfig ){

	return cudaFuncSetCacheConfig( func, cacheConfig );

}

cudaError_t WINAPI wine_cudaLaunch(const char *entry) {

	return cudaLaunch(entry);

}

cudaError_t WINAPI wine_cudaFuncGetAttributes( struct cudaFuncAttributes *attr, const char *func ){

	return cudaFuncGetAttributes( attr, func );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaStreamCreate( cudaStream_t *pStream ){

	return cudaStreamCreate( pStream );

}

cudaError_t WINAPI wine_cudaStreamDestroy( cudaStream_t stream ){

	return cudaStreamDestroy( stream );

}

cudaError_t WINAPI wine_cudaStreamSynchronize( cudaStream_t stream ){

	return cudaStreamSynchronize( stream );

}

cudaError_t WINAPI wine_cudaStreamQuery(cudaStream_t stream){

	return cudaStreamQuery( stream );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaEventCreate( cudaEvent_t *event ){

	return cudaEventCreate( event );

}

cudaError_t WINAPI wine_cudaEventCreateWithFlags( cudaEvent_t *event, int flags ){

	return cudaEventCreateWithFlags( event, flags );

}

cudaError_t WINAPI wine_cudaEventRecord( cudaEvent_t event, cudaStream_t stream ){

	return cudaEventRecord( event, stream );

}

cudaError_t WINAPI wine_cudaEventQuery( cudaEvent_t event ){

	return cudaEventQuery( event );

}

cudaError_t WINAPI wine_cudaEventSynchronize( cudaEvent_t event ){

	return cudaEventSynchronize( event );

}

cudaError_t WINAPI wine_cudaEventDestroy( cudaEvent_t event ){

	return cudaEventDestroy( event );

}

cudaError_t WINAPI wine_cudaEventElapsedTime( float *ms, cudaEvent_t start, cudaEvent_t end ){

	return cudaEventElapsedTime( ms, start, end );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaSetDoubleForDevice( double *d ){

	return cudaSetDoubleForDevice( d );

}

cudaError_t WINAPI wine_cudaSetDoubleForHost( double *d ){

	return cudaSetDoubleForHost( d );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaThreadExit( void ){

	return cudaThreadExit(  );

}

cudaError_t WINAPI wine_cudaThreadSynchronize( void ){

	return cudaThreadSynchronize(  );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaDriverGetVersion( int *driverVersion ){

	return cudaDriverGetVersion( driverVersion );

}

cudaError_t WINAPI wine_cudaRuntimeGetVersion( int *runtimeVersion ){

	return cudaRuntimeGetVersion( runtimeVersion );

}

/************************************************************

*******************

*																			  *

*			 cuda_runtime_api.h											   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGraphicsUnregisterResource( struct cudaGraphicsResource *resource ){

	return cudaGraphicsUnregisterResource( resource );

}

cudaError_t WINAPI wine_cudaGraphicsResourceSetMapFlags( struct cudaGraphicsResource *resource, unsigned int flags ){

	return cudaGraphicsResourceSetMapFlags( resource, flags );

}

cudaError_t WINAPI wine_cudaGraphicsMapResources( int count, struct cudaGraphicsResource **resources, cudaStream_t stream ){

	return cudaGraphicsMapResources( count, resources, stream );

}

cudaError_t WINAPI wine_cudaGraphicsUnmapResources( int count, struct cudaGraphicsResource **resources, cudaStream_t stream ){

	return cudaGraphicsUnmapResources( count, resources, stream );

}

cudaError_t WINAPI wine_cudaGraphicsResourceGetMappedPointer( void **devPtr, size_t *size, struct cudaGraphicsResource *resource){

	return cudaGraphicsResourceGetMappedPointer( devPtr, size, resource );

}

cudaError_t WINAPI wine_cudaGraphicsSubResourceGetMappedArray( struct cudaArray **arrayPtr, struct cudaGraphicsResource *resource, unsigned int arrayIndex, unsigned int mipLevel){

	return cudaGraphicsSubResourceGetMappedArray( arrayPtr, resource, arrayIndex, mipLevel );

}

/************************************************************

*******************

*																			  *

*				  cuda_gl_interop.h										   *

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGLSetGLDevice(int device){

	return cudaGLSetGLDevice( device );

}

cudaError_t WINAPI wine_cudaGraphicsGLRegisterImage( struct cudaGraphicsResource **resource, GLuint image, GLenum target, unsigned int Flags ){

	return cudaGraphicsGLRegisterImage( resource, image, target, Flags );

}

cudaError_t WINAPI wine_cudaGraphicsGLRegisterBuffer( struct cudaGraphicsResource **resource, GLuint buffer, unsigned int Flags ){

	return cudaGraphicsGLRegisterBuffer( resource, buffer, Flags );

}

/*cudaError_t WINAPI wine_cudaWGLGetDevice( int *device, HGPUNV hGpu ){

	return cudaWGLGetDevice( device, hGpu );

}*/

/************************************************************

*******************

*																			  *

*				 cuda_gl_interop.h											*

*																			  *

************************************************************

*******************/

cudaError_t WINAPI wine_cudaGLRegisterBufferObject( GLuint bufObj ){

	return cudaGLRegisterBufferObject( bufObj );

}

cudaError_t WINAPI wine_cudaGLMapBufferObject( void** devPtr, GLuint bufObj ){

	return cudaGLMapBufferObject( devPtr, bufObj );

}

cudaError_t WINAPI wine_cudaGLUnmapBufferObject( GLuint bufObj ){

	return cudaGLUnmapBufferObject( bufObj );

}

cudaError_t WINAPI wine_cudaGLUnregisterBufferObject( GLuint bufObj ){

	return cudaGLUnregisterBufferObject( bufObj );

}

cudaError_t WINAPI wine_cudaGLSetBufferObjectMapFlags( GLuint bufObj, unsigned int flags ){

	return cudaGLSetBufferObjectMapFlags( bufObj, flags ); 

}

cudaError_t WINAPI wine_cudaGLMapBufferObjectAsync( void **devPtr, GLuint bufObj, cudaStream_t stream ){

	return cudaGLMapBufferObjectAsync( devPtr, bufObj, stream );

}

cudaError_t WINAPI wine_cudaGLUnmapBufferObjectAsync( GLuint bufObj, cudaStream_t stream){

	return cudaGLUnmapBufferObjectAsync( bufObj, stream );

}

/************************************************************

*******************

*																			  *

*				  host_runtime.h											  *

*																			  *

************************************************************

*******************/

void** WINAPI wine_cudaRegisterFatBinary( void *fatCubin ) {

		return __cudaRegisterFatBinary( fatCubin );

	}

void WINAPI wine_cudaUnregisterFatBinary( void **fatCubinHandle ) {

		return __cudaUnregisterFatBinary( fatCubinHandle );

	}

void WINAPI wine_cudaRegisterVar( void **fatCubinHandle, char *hostVar, char *deviceAddress, const char  *deviceName, int ext, int size, int constant, int global ){

		return __cudaRegisterVar( fatCubinHandle, hostVar, deviceAddress, deviceName, ext, size, constant, global );

	}

void WINAPI wine_cudaRegisterTexture( void **fatCubinHandle, const struct textureReference *hostVar, const void **deviceAddress, const char *deviceName, int dim, int norm, int ext ){

	return __cudaRegisterTexture( fatCubinHandle, hostVar, deviceAddress, deviceName, dim, norm, ext );

}

void WINAPI wine_cudaRegisterShared( void **fatCubinHandle, void **devicePtr ) {

	return __cudaRegisterShared( fatCubinHandle, devicePtr );

	}

void WINAPI wine_cudaRegisterSharedVar(void **fatCubinHandle, void **devicePtr, size_t size, size_t alignment, int storage) {

	return __cudaRegisterSharedVar( fatCubinHandle, devicePtr, size, alignment, storage);

	}

void WINAPI wine_cudaRegisterFunction( void **fatCubinHandle, const char *hostFun, char *deviceFun, const char *deviceName, int thread_limit, uint3 *tid, uint3 *bid, dim3 *bDim, dim3 *gDim, int *wSize ) {

	return __cudaRegisterFunction( fatCubinHandle, hostFun, deviceFun, deviceName, thread_limit, tid, bid, bDim, gDim, wSize );

	}

/************************************************************

*******************

*																			  *

*			   device_functions.h											 *

*																			  *

************************************************************

*******************/

int WINAPI wine_cudaSynchronizeThreads( void **one, void *two  ){

	return __cudaSynchronizeThreads( one, two );

}

/************************************************************

*******************

*																			  *

*				texture_fetch_functions.h									 *

*																			  *

************************************************************

*******************/

void WINAPI wine_cudaTextureFetch( const void *tex, void *index, int integer, void *val ){

	return __cudaTextureFetch( tex, index, integer, val );

}

/************************************************************

*******************

*																			  *

*				sm_20_atomic_functions.h									  *

*																			  *

************************************************************

*******************/

void WINAPI wine_cudaMutexOperation( int lock ){

	return __cudaMutexOperation( lock );

}

cudart.dll.spec

#

# File: cudart.dll.spec

#

# Copyrighted by Seth Shelnutt under the LGPL v2.1 or later

#

# Wine spec file for the cudart.dll built-in library (a minimal wrapper around the

# linux library libcuart)

#

# For further details of wine spec files see the Winelib documentation at

# www.winehq.org

@  stdcall cudaGetDeviceCount( ptr ) wine_cudaGetDeviceCount

@  stdcall cudaSetDevice( long ) wine_cudaSetDevice

@  stdcall cudaGetDevice( ptr ) wine_cudaGetDevice

@  stdcall cudaGetDeviceProperties( ptr long ) wine_cudaGetDeviceProperties

@  stdcall cudaChooseDevice( ptr  ptr ) wine_cudaChooseDevice

@  stdcall cudaThreadSynchronize(  ) wine_cudaThreadSynchronize

@  stdcall cudaThreadExit(  ) wine_cudaThreadExit

@  stdcall cudaStreamCreate( ptr ) wine_cudaStreamCreate

@  stdcall cudaStreamQuery( long ) wine_cudaStreamQuery

@  stdcall cudaStreamSynchronize( long ) wine_cudaStreamSynchronize

@  stdcall cudaStreamDestroy( long ) wine_cudaStreamDestroy

@  stdcall cudaEventCreate( ptr ) wine_cudaEventCreate

@  stdcall cudaEventRecord( long long ) wine_cudaEventRecord

@  stdcall cudaEventQuery( long ) wine_cudaEventQuery

@  stdcall cudaEventSynchronize( long ) wine_cudaEventSynchronize

@  stdcall cudaEventDestroy( long ) wine_cudaEventDestroy

@  stdcall cudaEventElapsedTime( ptr long long ) wine_cudaEventElapsedTime

@  stdcall cudaConfigureCall( long long long long) wine_cudaConfigureCall

@  stdcall cudaLaunch( ptr ) wine_cudaLaunch

@  stdcall cudaSetupArgument( ptr long long ) wine_cudaSetupArgument

@  stdcall cudaMalloc( ptr long ) wine_cudaMalloc

@  stdcall cudaMallocPitch( ptr ptr long long ) wine_cudaMallocPitch

@  stdcall cudaFree( ptr ) wine_cudaFree

@  stdcall cudaMallocArray( ptr ptr long long ) wine_cudaMallocArray

@  stdcall cudaFreeArray( ptr ) wine_cudaFreeArray

@  stdcall cudaMallocHost( ptr long ) wine_cudaMallocHost

@  stdcall cudaFreeHost( ptr ) wine_cudaFreeHost

@  stdcall cudaMemset( ptr long long ) wine_cudaMemset

@  stdcall cudaMemset2D( ptr long long long long ) wine_cudaMemset2D

@  stdcall cudaMemcpy( ptr ptr long  long ) wine_cudaMemcpy

@  stdcall cudaMemcpyAsync( ptr ptr long  long long ) wine_cudaMemcpyAsync

@  stdcall cudaMemcpy2D( ptr long ptr long long long long ) wine_cudaMemcpy2D

@  stdcall cudaMemcpy2DAsync( ptr long ptr long long long long long ) wine_cudaMemcpy2DAsync

@  stdcall cudaMemcpyToArray( ptr long long ptr long long ) wine_cudaMemcpyToArray

@  stdcall cudaMemcpyToArrayAsync( ptr long long ptr long long long ) wine_cudaMemcpyToArrayAsync

@  stdcall cudaMemcpy2DToArray( ptr long long ptr long long long long ) wine_cudaMemcpy2DToArray

@  stdcall cudaMemcpy2DToArrayAsync( ptr long long ptr long long long long long ) wine_cudaMemcpy2DToArrayAsync

@  stdcall cudaMemcpyFromArray( ptr ptr long long long long ) wine_cudaMemcpyFromArray

@  stdcall cudaMemcpyFromArrayAsync( ptr ptr long long long long long ) wine_cudaMemcpyFromArrayAsync

@  stdcall cudaMemcpy2DFromArray( ptr long ptr long long long long long ) wine_cudaMemcpy2DFromArray

@  stdcall cudaMemcpy2DFromArrayAsync( ptr long ptr long long long long long long ) wine_cudaMemcpy2DFromArrayAsync

@  stdcall cudaMemcpyArrayToArray( ptr long long ptr long long long long ) wine_cudaMemcpyArrayToArray

@  stdcall cudaMemcpy2DArrayToArray( ptr long long ptr long long long long long ) wine_cudaMemcpy2DArrayToArray

@  stdcall cudaMemcpyToSymbol( long ptr long long long ) wine_cudaMemcpyToSymbol

@  stdcall cudaMemcpyFromSymbol( ptr long long long long ) wine_cudaMemcpyFromSymbol

@  stdcall cudaGetSymbolAddress( ptr ptr ) wine_cudaGetSymbolAddress

@  stdcall cudaGetSymbolSize( ptr ptr ) wine_cudaGetSymbolSize

@  stdcall cudaMalloc3D( ptr long ) wine_cudaMalloc3D

@  stdcall cudaMalloc3DArray( ptr ptr long ) wine_cudaMalloc3DArray

@  stdcall cudaMemset3D( long long long ) wine_cudaMemset3D

@  stdcall cudaMemcpy3D( long ) wine_cudaMemcpy3D

@  stdcall cudaMemcpy3DAsync( long long ) wine_cudaMemcpy3DAsync

@  stdcall cudaBindTexture( ptr ptr ptr ptr long ) wine_cudaBindTexture

@  stdcall cudaBindTextureToArray( ptr ptr ptr ) wine_cudaBindTextureToArray

@  stdcall cudaUnbindTexture( ptr ) wine_cudaUnbindTexture

@  stdcall cudaGetChannelDesc( ptr ptr ) wine_cudaGetChannelDesc

@  stdcall cudaGetTextureReference( ptr long) wine_cudaGetTextureReference

@  stdcall cudaGetTextureAlignmentOffset( ptr ptr ) wine_cudaGetTextureAlignmentOffset

@  stdcall cudaGLSetGLDevice( long ) wine_cudaGLSetGLDevice

@  stdcall cudaGLRegisterBufferObject( long ) wine_cudaGLRegisterBufferObject

@  stdcall cudaGLMapBufferObject( ptr long ) wine_cudaGLMapBufferObject

@  stdcall cudaGLUnmapBufferObject( long ) wine_cudaGLUnmapBufferObject

@  stdcall cudaGLUnregisterBufferObject( long ) wine_cudaGLUnregisterBufferObject

#Direct3D functions were skipped, implementation at a later time

@  stdcall cudaGetLastError(  ) wine_cudaGetLastError

@  stdcall cudaGetErrorString( long  ) wine_cudaGetErrorString

@ stdcall __cudaRegisterFatBinary( ptr ) wine_cudaRegisterFatBinary

@ stdcall __cudaRegisterFunction( ptr ptr ptr ptr long ptr ptr ptr ptr ptr ) wine_cudaRegisterFunction

@ stdcall __cudaRegisterVar( ptr ptr ptr ptr long long long long ) wine_cudaRegisterVar

@ stdcall __cudaRegisterShared( ptr ptr ) wine_cudaRegisterShared

@ stdcall __cudaRegisterSharedVar( ptr ptr long long long ) wine_cudaRegisterSharedVar

@ stdcall __cudaUnregisterFatBinary( ptr ) wine_cudaUnregisterFatBinary

#New to cuda 3.0

@ stdcall __cudaMutexOperation( long ) wine_cudaMutexOperation

@ stdcall __cudaRegisterTexture( ptr ptr ptr ptr long long long ) wine_cudaRegisterTexture

@ stdcall __cudaSynchronizeThreads( ) wine_cudaSynchronizeThreads

@ stdcall __cudaTextureFetch( ptr ptr long ptr) wine_cudaTextureFetch

#@ stdcall cudaBindTexture2D( ptr ptr ptr ptr long long long ) wine_cudaBindTexture2D

@ stdcall cudaCreateChannelDesc( long long long long long ) wine_cudaCreateChannelDesc

@ stdcall cudaDriverGetVersion( long ) wine_cudaDriverGetVersion

@ stdcall cudaEventCreateWithFlags( ptr long) wine_cudaEventCreateWithFlags

@ stdcall cudaFuncGetAttributes( ptr ptr ) wine_cudaFuncGetAttributes

@ stdcall cudaFuncSetCacheConfig( ptr long ) wine_cudaFuncSetCacheConfig

@ stdcall cudaGLMapBufferObjectAsync( ptr long long ) wine_cudaGLMapBufferObjectAsync

@ stdcall cudaGLSetBufferObjectMapFlags( long long ) wine_cudaGLSetBufferObjectMapFlags

@ stdcall cudaGLUnmapBufferObjectAsync( long long ) wine_cudaGLUnmapBufferObjectAsync

@ stdcall cudaGraphicsGLRegisterBuffer( ptr long long ) wine_cudaGraphicsGLRegisterBuffer

@ stdcall cudaGraphicsGLRegisterImage( ptr long long long ) wine_cudaGraphicsGLRegisterImage

@ stdcall cudaGraphicsMapResources( long ptr long ) wine_cudaGraphicsMapResources

@ stdcall cudaGraphicsResourceGetMappedPointer( ptr ptr ptr ) wine_cudaGraphicsResourceGetMappedPointer

@ stdcall cudaGraphicsResourceSetMapFlags( ptr long ) wine_cudaGraphicsResourceSetMapFlags

@ stdcall cudaGraphicsSubResourceGetMappedArray( ptr ptr long long ) wine_cudaGraphicsSubResourceGetMappedArray

@ stdcall cudaGraphicsUnmapResources( long ptr long ) wine_cudaGraphicsUnmapResources

@ stdcall cudaGraphicsUnregisterResource( ptr ) wine_cudaGraphicsUnregisterResource

@ stdcall cudaHostAlloc( ptr long long ) wine_cudaHostAlloc

@ stdcall cudaHostGetDevicePointer( ptr ptr long ) wine_cudaHostGetDevicePointer

@ stdcall cudaHostGetFlags( ptr ptr ) wine_cudaHostGetFlags

@ stdcall cudaMemGetInfo( ptr ptr ) wine_cudaMemGetInfo

#@ stdcall cudaMemcpyFromSymbolAsync( ptr ptr long long long long ) wine_cudaMemcpyFromSymbolAsync

#@ stdcall cudaMemcpyToSymbolAsync( ptr ptr long long long long ) wine_cudaMemcpyToSymbolAsync

@ stdcall cudaRuntimeGetVersion( long ) wine_cudaRuntimeGetVersion

#@ stdcall cudaSetDeviceFlags( long ) wine_cudaSetDeviceFlags

@ stdcall cudaSetDoubleForDevice( ptr ) wine_cudaSetDoubleForDevice

@ stdcall cudaSetDoubleForHost( ptr ) wine_cudaSetDoubleForHost

#@ stdcall cudaSetValidDevices( ptr long ) wine_cudaSetValidDevices

#@ stdcall cudaWGLGetDevice( ptr long ) wine_cudaWGLGetDevice

makefile

### Generated by Winemaker 0.7.4

SRCDIR				= .

SUBDIRS			   =

DLLS				  = cudart.dll

EXES				  =

### Common settings

CEXTRA				= -mno-cygwin

CXXEXTRA			  = -mno-cygwin

RCEXTRA			   =

DEFINES			   =

INCLUDE_PATH		  = -I/usr/local/cuda/include/

DLL_PATH			  =

DLL_IMPORTS		   =

LIBRARY_PATH		  = -L/usr/local/cuda/lib/

LIBRARIES			 = -lcudart

### cudart.dll sources and settings

cudart_dll_MODULE	 = cudart.dll

cudart_dll_C_SRCS	 = cudart.c

cudart_dll_CXX_SRCS   =

cudart_dll_RC_SRCS	=

cudart_dll_LDFLAGS	= -shared \

			$(cudart_dll_MODULE:%=%.spec) \

			-mno-cygwin

cudart_dll_DLL_PATH   =

cudart_dll_DLLS	   = odbc32 \

			ole32 \

			oleaut32 \

			winspool \

			odbccp32

cudart_dll_LIBRARY_PATH=

cudart_dll_LIBRARIES  = uuid

cudart_dll_OBJS	   = $(cudart_dll_C_SRCS:.c=.o) \

			$(cudart_dll_CXX_SRCS:.cpp=.o) \

			$(cudart_dll_RC_SRCS:.rc=.res)

### Global source lists

C_SRCS				= $(cudart_dll_C_SRCS)

CXX_SRCS			  = $(cudart_dll_CXX_SRCS)

RC_SRCS			   = $(cudart_dll_RC_SRCS)

### Tools

CC = winegcc

CXX = wineg++

RC = wrc

### Generic targets

all: $(SUBDIRS) $(DLLS:%=%.so) $(EXES:%=%.so)

### Build rules

.PHONY: all clean dummy

$(SUBDIRS): dummy

	@cd $@ && $(MAKE)

# Implicit rules

.SUFFIXES: .cpp .rc .res

DEFINCL = $(INCLUDE_PATH) $(DEFINES) $(OPTIONS)

.c.o:

	$(CC) -c $(CFLAGS) $(CEXTRA) $(DEFINCL) -o $@ $<

.cpp.o:

	$(CXX) -c $(CXXFLAGS) $(CXXEXTRA) $(DEFINCL) -o $@ $<

.cxx.o:

	$(CXX) -c $(CXXFLAGS) $(CXXEXTRA) $(DEFINCL) -o $@ $<

.rc.res:

	$(RC) $(RCFLAGS) $(RCEXTRA) $(DEFINCL) -fo$@ $<

# Rules for cleaning

CLEAN_FILES	 = y.tab.c y.tab.h lex.yy.c core *.orig *.rej \

				  \\#*\\# *~ *% .\\#*

clean:: $(SUBDIRS:%=%/__clean__) $(EXTRASUBDIRS:%=%/__clean__)

	$(RM) $(CLEAN_FILES) $(RC_SRCS:.rc=.res) $(C_SRCS:.c=.o) $(CXX_SRCS:.cpp=.o)

	$(RM) $(DLLS:%=%.so) $(EXES:%=%.so) $(EXES:%.exe=%)

$(SUBDIRS:%=%/__clean__): dummy

	cd `dirname $@` && $(MAKE) clean

$(EXTRASUBDIRS:%=%/__clean__): dummy

	-cd `dirname $@` && $(RM) $(CLEAN_FILES)

### Target specific build rules

DEFLIB = $(LIBRARY_PATH) $(LIBRARIES) $(DLL_PATH) $(DLL_IMPORTS:%=-l%)

$(cudart_dll_MODULE).so: $(cudart_dll_OBJS)

	$(CC) $(cudart_dll_LDFLAGS) -o $@ $(cudart_dll_OBJS) $(cudart_dll_LIBRARY_PATH) $(DEFLIB) $(cudart_dll_DLLS:%=-l%) $(cudart_dll_LIBRARIES:%=-l%)

Also I used nm to try and find out which lib had the functions but none of the libs have the functions.

libcublas.so.3.0.14:

		 w _Jv_RegisterClasses

		 U __cudaRegisterFatBinary

		 U __cudaRegisterFunction

		 U __cudaRegisterSharedVar

		 U __cudaRegisterTexture

		 U __cudaUnregisterFatBinary

		 U __cxa_atexit

		 w __cxa_finalize

		 w __gmon_start__

		 U __gxx_personality_v0

		 w __isinf

		 w __isnan

		 U calloc

		 w cos

00076da0 T cublasAlloc

000e0ac0 T cublasCaxpy

000e1710 T cublasCcopy

000e2580 T cublasCdotc

000e39e0 T cublasCdotu

000882b0 T cublasCgbmv

000f4f70 T cublasCgemm

00173e30 T cublasCgemv

001382e0 T cublasCgerc

00137390 T cublasCgeru

00096900 T cublasChbmv

0012e350 T cublasChemm

000a5c50 T cublasChemv

0013c060 T cublasCher

0013de30 T cublasCher2

00164000 T cublasCher2k

001609d0 T cublasCherk

0009a670 T cublasChpmv

0013fdc0 T cublasChpr

000a00a0 T cublasChpr2

000e4c40 T cublasCrot

000e5740 T cublasCrotg

000e66e0 T cublasCscal

000e7ed0 T cublasCsrot

000e72f0 T cublasCsscal

000e8ae0 T cublasCswap

00129fc0 T cublasCsymm

0015dbc0 T cublasCsyr2k

0015a3d0 T cublasCsyrk

000b1fe0 T cublasCtbmv

000b9350 T cublasCtbsv

000c0650 T cublasCtpmv

000c75c0 T cublasCtpsv

0011d400 T cublasCtrmm

000ea150 T cublasCtrmv

0010b520 T cublasCtrsm

000df190 T cublasCtrsv

00146fe0 T cublasDasum

00148290 T cublasDaxpy

001493b0 T cublasDcopy

0014bc90 T cublasDdot

00087210 T cublasDgbmv

00104360 T cublasDgemm

00135420 T cublasDgemv

00136430 T cublasDger

0014f840 T cublasDnrm2

00150f40 T cublasDrot

00151690 T cublasDrotg

00152af0 T cublasDrotm

00153020 T cublasDrotmg

00095930 T cublasDsbmv

00154a90 T cublasDscal

000996d0 T cublasDspmv

0009d390 T cublasDspr

0009f140 T cublasDspr2

00155ba0 T cublasDswap

00127b30 T cublasDsymm

000a4c90 T cublasDsymv

0013b210 T cublasDsyr

000a9b30 T cublasDsyr2

00133f00 T cublasDsyr2k

001326e0 T cublasDsyrk

000afcf0 T cublasDtbmv

000b7da0 T cublasDtbsv

000be480 T cublasDtpmv

000c60b0 T cublasDtpsv

001177d0 T cublasDtrmm

00145630 T cublasDtrmv

00111950 T cublasDtrsm

00141c40 T cublasDtrsv

00167ec0 T cublasDzasum

000f0ee0 T cublasDznrm2

00077330 T cublasFree

00076d40 T cublasGetError

00076e70 T cublasGetMatrix

000770f0 T cublasGetVector

000ec070 T cublasIcamax

000ed660 T cublasIcamin

00156c80 T cublasIdamax

001583e0 T cublasIdamin

00076ce0 T cublasInit

00076b60 T cublasInitCtx

000761d0 T cublasInitialized

000780a0 T cublasIsamax

00079690 T cublasIsamin

00177740 T cublasIzamax

00178ea0 T cublasIzamin

0007ada0 T cublasSasum

0007bfd0 T cublasSaxpy

000eed70 T cublasScasum

000efd50 T cublasScnrm2

0007d070 T cublasScopy

0007e140 T cublasSdot

00076190 T cublasSetError

00076fb0 T cublasSetMatrix

00077210 T cublasSetVector

00086260 T cublasSgbmv

0008a240 T cublasSgemm

00092cb0 T cublasSgemv

00093bc0 T cublasSger

000762a0 T cublasShutDownCtx

00076b40 T cublasShutdown

0007f4c0 T cublasSnrm2

00080730 T cublasSrot

00081510 T cublasSrotg

00082260 T cublasSrotm

000830c0 T cublasSrotmg

00094a00 T cublasSsbmv

00084220 T cublasSscal

000987f0 T cublasSspmv

0009c540 T cublasSspr

0009e230 T cublasSspr2

00085290 T cublasSswap

000a2840 T cublasSsymm

000a3d80 T cublasSsymv

000a7d50 T cublasSsyr

000a8bf0 T cublasSsyr2

000ac500 T cublasSsyr2k

000ab260 T cublasSsyrk

000ade00 T cublasStbmv

000b69f0 T cublasStbsv

000bc690 T cublasStpmv

000c4db0 T cublasStpsv

000cf2e0 T cublasStrmm

000d3180 T cublasStrmv

000d9b20 T cublasStrsm

000dd890 T cublasStrsv

02cbbe48 B cublasThreadContext

000f93e0 T cublasXerbla

001707e0 T cublasZaxpy

0014a210 T cublasZcopy

0014e4d0 T cublasZdotc

0014d090 T cublasZdotu

001768f0 T cublasZdrot

001670e0 T cublasZdscal

00089400 T cublasZgbmv

000fccb0 T cublasZgemm

00168fa0 T cublasZgemv

0013a230 T cublasZgerc

00139230 T cublasZgeru

000978a0 T cublasZhbmv

00130810 T cublasZhemm

000a6bf0 T cublasZhemv

0013cf00 T cublasZher

0013ee20 T cublasZher2

00165280 T cublasZher2k

00162c80 T cublasZherk

0009b5f0 T cublasZhpmv

00140c10 T cublasZhpr

000a1050 T cublasZhpr2

00174db0 T cublasZrot

00175940 T cublasZrotg

00166430 T cublasZscal

0014ae10 T cublasZswap

0012c480 T cublasZsymm

0015ee50 T cublasZsyr2k

0015c780 T cublasZsyrk

000b48c0 T cublasZtbmv

000bac00 T cublasZtbsv

000c2de0 T cublasZtpmv

000c8db0 T cublasZtpsv

001234f0 T cublasZtrmm

00171f40 T cublasZtrmv

0016c720 T cublasZtrsm

001435e0 T cublasZtrsv

		 U cudaBindTexture

		 U cudaConfigureCall

		 U cudaCreateChannelDesc

		 U cudaFree

		 U cudaFuncGetAttributes

		 U cudaGetDevice

		 U cudaGetDeviceProperties

		 U cudaGetLastError

		 U cudaLaunch

		 U cudaMalloc

		 U cudaMemcpy

		 U cudaMemcpy2D

		 U cudaSetupArgument

		 U cudaUnbindTexture

		 w exp

		 w exp2

		 U fprintf

		 U free

		 w log

		 w log1p

		 w log2

		 U malloc

		 U memalign

		 U memcpy

		 U memset

		 U pthread_getspecific

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 w remquo

		 w sin

		 w sqrt

		 w sqrtf

		 U stdout

		 U strncpy

		 U toupper

libcublasemu.so.3.0.14:

		 w _Jv_RegisterClasses

		 U __cudaRegisterFatBinary

		 U __cudaRegisterFunction

		 U __cudaRegisterSharedVar

		 U __cudaRegisterTexture

		 U __cudaSynchronizeThreads

		 U __cudaTextureFetch

		 U __cudaUnregisterFatBinary

		 U __cxa_atexit

		 w __cxa_finalize

		 w __gmon_start__

		 U __gxx_personality_v0

		 w __isinf

		 w __isnan

		 U calloc

		 w cos

001c4c50 T cublasAlloc

0047bfe0 T cublasCaxpy

0047d060 T cublasCcopy

00482b00 T cublasCdotc

00488160 T cublasCdotu

001f1850 T cublasCgbmv

0053e0c0 T cublasCgemm

018a19b0 T cublasCgemv

01000b50 T cublasCgerc

00ffb500 T cublasCgeru

00256960 T cublasChbmv

00f70fc0 T cublasChemm

002cc2f0 T cublasChemv

01018610 T cublasCher

01025ca0 T cublasCher2

0138c030 T cublasCher2k

0127fbe0 T cublasCherk

002770b0 T cublasChpmv

010372d0 T cublasChpr

00296fc0 T cublasChpr2

00493ec0 T cublasCrot

00494a60 T cublasCrotg

00496460 T cublasCscal

00498d00 T cublasCsrot

00497370 T cublasCsscal

0049a160 T cublasCswap

00f085c0 T cublasCsymm

011f6800 T cublasCsyr2k

01105f90 T cublasCsyrk

00311930 T cublasCtbmv

0033bb70 T cublasCtbsv

00361e50 T cublasCtpmv

00387760 T cublasCtpsv

00b7a3e0 T cublasCtrmm

004a6a30 T cublasCtrmv

009367b0 T cublasCtrsm

00478290 T cublasCtrsv

01059860 T cublasDasum

0105d410 T cublasDaxpy

0105f100 T cublasDcopy

01065b50 T cublasDdot

001e2ce0 T cublasDgbmv

006b0040 T cublasDgemm

00ff33f0 T cublasDgemv

00ff61b0 T cublasDger

0107d560 T cublasDnrm2

01080620 T cublasDrot

01080d80 T cublasDrotg

01084dc0 T cublasDrotm

01085300 T cublasDrotmg

0024cb30 T cublasDsbmv

01087630 T cublasDscal

0026cb10 T cublasDspmv

0028c5a0 T cublasDspr

0028f6c0 T cublasDspr2

01089cb0 T cublasDswap

00ef4980 T cublasDsymm

002c1d60 T cublasDsymv

01014d40 T cublasDsyr

002e3d40 T cublasDsyr2

00fef590 T cublasDsyr2k

00fdd450 T cublasDsyrk

00303740 T cublasDtbmv

00331860 T cublasDtbsv

00355b60 T cublasDtpmv

0037d820 T cublasDtpsv

00985c00 T cublasDtrmm

01055ee0 T cublasDtrmv

0093e0b0 T cublasDtrsm

01040630 T cublasDtrsv

01393f90 T cublasDzasum

004b1710 T cublasDznrm2

001c51e0 T cublasFree

001c4bf0 T cublasGetError

001c4d20 T cublasGetMatrix

001c4fa0 T cublasGetVector

004a94a0 T cublasIcamax

004ab5d0 T cublasIcamin

0108b640 T cublasIdamax

0108d750 T cublasIdamin

001c4b90 T cublasInit

001c4a10 T cublasInitCtx

001c4080 T cublasInitialized

001c67a0 T cublasIsamax

001c87d0 T cublasIsamin

018bc120 T cublasIzamax

018be940 T cublasIzamin

001cab10 T cublasSasum

001ccd10 T cublasSaxpy

004ad650 T cublasScasum

004af550 T cublasScnrm2

001cebc0 T cublasScopy

001d0b10 T cublasSdot

001c4040 T cublasSetError

001c4e60 T cublasSetMatrix

001c50c0 T cublasSetVector

001e0af0 T cublasSgbmv

0020dbd0 T cublasSgemm

00247520 T cublasSgemv

00248bf0 T cublasSger

001c4150 T cublasShutDownCtx

001c49f0 T cublasShutdown

001d36e0 T cublasSnrm2

001d5f10 T cublasSrot

001d6d80 T cublasSrotg

001d9f40 T cublasSrotm

001dada0 T cublasSrotmg

0024a9d0 T cublasSsbmv

001dc670 T cublasSscal

0026aae0 T cublasSspmv

0028af60 T cublasSspr

0028dd50 T cublasSspr2

001deb60 T cublasSswap

002bd7a0 T cublasSsymm

002bfca0 T cublasSsymv

002e0b40 T cublasSsyr

002e2320 T cublasSsyr2

002f9b90 T cublasSsyr2k

002f88f0 T cublasSsyrk

002fe670 T cublasStbmv

0032d660 T cublasStbsv

00350c40 T cublasStpmv

00379b30 T cublasStpsv

003e7760 T cublasStrmm

003f6180 T cublasStrmv

00460ad0 T cublasStrsm

0046de90 T cublasStrsv

019229e8 B cublasThreadContext

00542590 T cublasXerbla

018778e0 T cublasZaxpy

010608a0 T cublasZcopy

01077ba0 T cublasZdotc

0106e3c0 T cublasZdotu

018ba090 T cublasZdrot

01391de0 T cublasZdscal

0020cd90 T cublasZgbmv

00547330 T cublasZgemm

013b9c80 T cublasZgemv

010120e0 T cublasZgerc

01009220 T cublasZgeru

00268d60 T cublasZhbmv

00f99a00 T cublasZhemm

002dec70 T cublasZhemv

0101dfe0 T cublasZher

01033b90 T cublasZher2

0138d2c0 T cublasZher2k

0138ac30 T cublasZherk

002898e0 T cublasZhpmv

0103cae0 T cublasZhpr

002a4b30 T cublasZhpr2

018b7240 T cublasZrot

018b7e60 T cublasZrotg

01390c90 T cublasZscal

010626d0 T cublasZswap

00f2f940 T cublasZsymm

011f7b30 T cublasZsyr2k

011f53d0 T cublasZsyrk

003286e0 T cublasZtbmv

0034c0d0 T cublasZtbsv

00375170 T cublasZtpmv

00397b70 T cublasZtpsv

00eeef20 T cublasZtrmm

0188c7a0 T cublasZtrmv

0186f2b0 T cublasZtrsm

01050f80 T cublasZtrsv

		 U cudaBindTexture

		 U cudaConfigureCall

		 U cudaCreateChannelDesc

		 U cudaFree

		 U cudaFuncGetAttributes

		 U cudaGetDevice

		 U cudaGetDeviceProperties

		 U cudaGetLastError

		 U cudaLaunch

		 U cudaMalloc

		 U cudaMemcpy

		 U cudaMemcpy2D

		 U cudaSetupArgument

		 U cudaUnbindTexture

		 w exp

		 w exp2

		 U fprintf

		 U free

		 w log

		 w log1p

		 w log2

		 U malloc

		 U memalign

		 U memcpy

		 U memset

		 U pthread_getspecific

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 w remquo

		 w sin

		 w sqrt

		 w sqrtf

		 U stdout

		 U strncpy

		 U toupper

libcudart.so.3.0.14:

		 w _Jv_RegisterClasses

		 U _Unwind_Resume

		 U _ZN9__gnu_cxx18__exchange_and_addEPVii

		 U _ZNSs4_Rep10_M_destroyERKSaIcE

		 U _ZNSs4_Rep20_S_empty_rep_storageE

		 U _ZNSsC1EPKcRKSaIcE

		 U _ZNSsC1ERKSs

		 U _ZNSt15_List_node_base4hookEPS_

		 U _ZNSt15_List_node_base6unhookEv

		 U _ZNSt9bad_allocD1Ev

		 U _ZSt17__throw_bad_allocv

		 U _ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base

		 U _ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base

		 U _ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base

		 U _ZSt20__throw_length_errorPKc

		 U _ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_

		 U _ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS

0_RS_

		 U _ZTISt9bad_alloc

		 U _ZTVN10__cxxabiv116__enum_type_infoE

		 U _ZTVN10__cxxabiv117__class_type_infoE

		 U _ZTVN10__cxxabiv120__si_class_type_infoE

		 U _ZTVSt9bad_alloc

		 U _ZdaPv

		 U _ZdlPv

		 U _Znaj

		 U _Znwj

000100a0 T __cudaMutexOperation

00014cc0 T __cudaRegisterFatBinary

000139f0 T __cudaRegisterFunction

00013ca0 T __cudaRegisterShared

00014460 T __cudaRegisterSharedVar

00013f20 T __cudaRegisterTexture

000141c0 T __cudaRegisterVar

0000fed0 T __cudaSynchronizeThreads

0000fee0 T __cudaTextureFetch

000146e0 T __cudaUnregisterFatBinary

		 U __cxa_allocate_exception

		 U __cxa_atexit

		 U __cxa_begin_catch

		 U __cxa_end_catch

		 w __cxa_finalize

		 U __cxa_get_exception_ptr

		 U __cxa_pure_virtual

		 U __cxa_rethrow

		 U __cxa_throw

		 w __gmon_start__

		 U __gxx_personality_v0

		 U calloc

00016cf0 T cudaBindTexture

00017160 T cudaBindTexture2D

00016910 T cudaBindTextureToArray

000204b0 T cudaChooseDevice

00023f20 T cudaConfigureCall

00010070 T cudaCreateChannelDesc

00013630 T cudaDriverGetVersion

0001f810 T cudaEventCreate

0001f3e0 T cudaEventCreateWithFlags

0001ed00 T cudaEventDestroy

0001ea70 T cudaEventElapsedTime

0001f170 T cudaEventQuery

00023520 T cudaEventRecord

0001ef40 T cudaEventSynchronize

0001cc70 T cudaFree

0001bf80 T cudaFreeArray

0001ca50 T cudaFreeHost

00025990 T cudaFuncGetAttributes

00026780 T cudaFuncSetCacheConfig

00018ec0 T cudaGLMapBufferObject

000246d0 T cudaGLMapBufferObjectAsync

00019170 T cudaGLRegisterBufferObject

00018700 T cudaGLSetBufferObjectMapFlags

00015810 T cudaGLSetGLDevice

00018b50 T cudaGLUnmapBufferObject

00024300 T cudaGLUnmapBufferObjectAsync

00018920 T cudaGLUnregisterBufferObject

00015c80 T cudaGetChannelDesc

000130e0 T cudaGetDevice

000212e0 T cudaGetDeviceCount

00020c40 T cudaGetDeviceProperties

0000ff40 T cudaGetErrorString

00012e70 T cudaGetLastError

000193a0 T cudaGetSymbolAddress

00024f80 T cudaGetSymbolSize

00016390 T cudaGetTextureAlignmentOffset

00015ee0 T cudaGetTextureReference

000182a0 T cudaGraphicsGLRegisterBuffer

000184d0 T cudaGraphicsGLRegisterImage

00023d20 T cudaGraphicsMapResources

00017c10 T cudaGraphicsResourceGetMappedPointer

00017e60 T cudaGraphicsResourceSetMapFlags

00017a10 T cudaGraphicsSubResourceGetMappedArray

00021e80 T cudaGraphicsUnmapResources

00018080 T cudaGraphicsUnregisterResource

0001d870 T cudaHostAlloc

0001d640 T cudaHostGetDevicePointer

0001d420 T cudaHostGetFlags

00025ec0 T cudaLaunch

0001dcf0 T cudaMalloc

0001cf20 T cudaMalloc3D

0001c280 T cudaMalloc3DArray

0001c670 T cudaMallocArray

0001dab0 T cudaMallocHost

0001d1b0 T cudaMallocPitch

0001bd60 T cudaMemGetInfo

0001bab0 T cudaMemcpy

0001b580 T cudaMemcpy2D

0001a440 T cudaMemcpy2DArrayToArray

00022fa0 T cudaMemcpy2DAsync

0001a7a0 T cudaMemcpy2DFromArray

00022080 T cudaMemcpy2DFromArrayAsync

0001ae70 T cudaMemcpy2DToArray

00022800 T cudaMemcpy2DToArrayAsync

0001a250 T cudaMemcpy3D

000249d0 T cudaMemcpy3DAsync

0001df30 T cudaMemcpyArrayToArray

00023200 T cudaMemcpyAsync

0001ab20 T cudaMemcpyFromArray

00022450 T cudaMemcpyFromArrayAsync

0001b7a0 T cudaMemcpyFromSymbol

00024c10 T cudaMemcpyFromSymbolAsync

0001b200 T cudaMemcpyToArray

00022bf0 T cudaMemcpyToArrayAsync

00025520 T cudaMemcpyToSymbol

00025730 T cudaMemcpyToSymbolAsync

0001a020 T cudaMemset

00019c40 T cudaMemset2D

000195d0 T cudaMemset3D

00013460 T cudaRuntimeGetVersion

000216c0 T cudaSetDevice

00012ed0 T cudaSetDeviceFlags

0001e510 T cudaSetDoubleForDevice

0001e300 T cudaSetDoubleForHost

00014ec0 T cudaSetValidDevices

0001e730 T cudaSetupArgument

0001fe60 T cudaStreamCreate

0001fc20 T cudaStreamDestroy

00023780 T cudaStreamQuery

000239f0 T cudaStreamSynchronize

000132c0 T cudaThreadExit

00020290 T cudaThreadSynchronize

00016620 T cudaUnbindTexture

		 U dlclose

		 U dlopen

		 U dlsym

		 U exit

		 U free

		 U getenv

		 U malloc

		 U memalign

		 U memcpy

		 U memmove

		 U memset

		 U pthread_getspecific

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 U strncmp

		 U strncpy

libcudartemu.so.3.0.14:

		 w _Jv_RegisterClasses

		 U _Unwind_Resume

		 U _ZN9__gnu_cxx18__exchange_and_addEPVii

		 U _ZNSs4_Rep10_M_destroyERKSaIcE

		 U _ZNSs4_Rep20_S_empty_rep_storageE

		 U _ZNSsC1EPKcRKSaIcE

		 U _ZNSsC1ERKSs

		 U _ZNSsD1Ev

		 U _ZNSt15_List_node_base4hookEPS_

		 U _ZNSt15_List_node_base6unhookEv

		 U _ZNSt9bad_allocD1Ev

		 U _ZSt17__throw_bad_allocv

		 U _ZSt18_Rb_tree_decrementPSt18_Rb_tree_node_base

		 U _ZSt18_Rb_tree_incrementPKSt18_Rb_tree_node_base

		 U _ZSt18_Rb_tree_incrementPSt18_Rb_tree_node_base

		 U _ZSt20__throw_length_errorPKc

		 U _ZSt28_Rb_tree_rebalance_for_erasePSt18_Rb_tree_node_baseRS_

		 U _ZSt29_Rb_tree_insert_and_rebalancebPSt18_Rb_tree_node_baseS

0_RS_

		 U _ZTISt9bad_alloc

		 U _ZTVN10__cxxabiv116__enum_type_infoE

		 U _ZTVN10__cxxabiv117__class_type_infoE

		 U _ZTVN10__cxxabiv120__si_class_type_infoE

		 U _ZTVSt9bad_alloc

		 U _ZdaPv

		 U _ZdlPv

		 U _Znaj

		 U _Znwj

0000f2b0 T __cudaMutexOperation

00012e20 T __cudaRegisterFatBinary

00012680 T __cudaRegisterFunction

000135b0 T __cudaRegisterShared

00012920 T __cudaRegisterSharedVar

00012b90 T __cudaRegisterTexture

00013320 T __cudaRegisterVar

00011900 T __cudaSynchronizeThreads

0000ffb0 T __cudaTextureFetch

000120d0 T __cudaUnregisterFatBinary

		 U __cxa_allocate_exception

		 U __cxa_atexit

		 U __cxa_begin_catch

		 U __cxa_end_catch

		 w __cxa_finalize

		 U __cxa_get_exception_ptr

		 U __cxa_pure_virtual

		 U __cxa_rethrow

		 U __cxa_throw

		 U __errno_location

		 w __gmon_start__

		 U __gxx_personality_v0

		 U __strtol_internal

		 U _setjmp

		 U calloc

		 U clock_gettime

00015880 T cudaBindTexture

00015cd0 T cudaBindTexture2D

000154b0 T cudaBindTextureToArray

00014110 T cudaChooseDevice

0001d180 T cudaConfigureCall

0000f280 T cudaCreateChannelDesc

000102e0 T cudaDriverGetVersion

0001e470 T cudaEventCreate

0001e0d0 T cudaEventCreateWithFlags

0001d7d0 T cudaEventDestroy

0001d550 T cudaEventElapsedTime

0001dc20 T cudaEventQuery

0001de80 T cudaEventRecord

0001da00 T cudaEventSynchronize

0001b6d0 T cudaFree

0001ab40 T cudaFreeArray

0001b500 T cudaFreeHost

000249c0 T cudaFuncGetAttributes

000244b0 T cudaFuncSetCacheConfig

00016d00 T cudaGLMapBufferObject

00016910 T cudaGLMapBufferObjectAsync

000170b0 T cudaGLRegisterBufferObject

00016170 T cudaGLSetBufferObjectMapFlags

000202f0 T cudaGLSetGLDevice

00016510 T cudaGLUnmapBufferObject

000221f0 T cudaGLUnmapBufferObjectAsync

00016340 T cudaGLUnregisterBufferObject

00014860 T cudaGetChannelDesc

000106e0 T cudaGetDevice

0001fa80 T cudaGetDeviceCount

0001f420 T cudaGetDeviceProperties

0000f150 T cudaGetErrorString

000100c0 T cudaGetLastError

00017280 T cudaGetSymbolAddress

00022d10 T cudaGetSymbolSize

00014f50 T cudaGetTextureAlignmentOffset

00014ab0 T cudaGetTextureReference

0001c330 T cudaHostAlloc

0001c160 T cudaHostGetDevicePointer

0001bf90 T cudaHostGetFlags

00023c00 T cudaLaunch

0001c7a0 T cudaMalloc

0001ba00 T cudaMalloc3D

0001ae30 T cudaMalloc3DArray

0001b1a0 T cudaMallocArray

0001c5c0 T cudaMallocHost

0001bcd0 T cudaMallocPitch

0001a960 T cudaMemGetInfo

000215c0 T cudaMemcpy

000197a0 T cudaMemcpy2D

000184a0 T cudaMemcpy2DArrayToArray

00022670 T cudaMemcpy2DAsync

000187f0 T cudaMemcpy2DFromArray

00021db0 T cudaMemcpy2DFromArrayAsync

00018fd0 T cudaMemcpy2DToArray

00021950 T cudaMemcpy2DToArrayAsync

000182c0 T cudaMemcpy3D

00018090 T cudaMemcpy3DAsync

00020ea0 T cudaMemcpyArrayToArray

0001a590 T cudaMemcpyAsync

00020af0 T cudaMemcpyFromArray

00018bf0 T cudaMemcpyFromArrayAsync

00023220 T cudaMemcpyFromSymbol

00019df0 T cudaMemcpyFromSymbolAsync

00020740 T cudaMemcpyToArray

000193e0 T cudaMemcpyToArrayAsync

00021260 T cudaMemcpyToSymbol

0001a1c0 T cudaMemcpyToSymbolAsync

00017e40 T cudaMemset

00017ab0 T cudaMemset2D

000174d0 T cudaMemset3D

00010120 T cudaRuntimeGetVersion

0001fe40 T cudaSetDevice

000104e0 T cudaSetDeviceFlags

0001cc40 T cudaSetDoubleForDevice

0001ca40 T cudaSetDoubleForHost

00013820 T cudaSetValidDevices

0001ce50 T cudaSetupArgument

0001eea0 T cudaStreamCreate

0001ec70 T cudaStreamDestroy

0001e7f0 T cudaStreamQuery

0001ea50 T cudaStreamSynchronize

000108b0 T cudaThreadExit

0001f250 T cudaThreadSynchronize

000151d0 T cudaUnbindTexture

		 U dlclose

		 U dlopen

		 U dlsym

		 U exit

		 U fclose

		 U fgets

		 U fopen

		 U free

		 U get_nprocs

		 U getenv

		 U gettimeofday

		 U localtime_r

		 U longjmp

		 U malloc

		 U memalign

		 U memcpy

		 U memmove

		 U memset

		 U pthread_attr_destroy

		 U pthread_attr_init

		 U pthread_attr_setstacksize

		 U pthread_barrier_destroy

		 U pthread_barrier_init

		 U pthread_barrier_wait

		 U pthread_create

		 U pthread_exit

		 U pthread_getspecific

		 U pthread_join

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_kill

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_trylock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 U roundf

		 U sched_yield

		 U sem_destroy

		 U sem_init

		 U sem_post

		 U sem_wait

		 U setenv

		 U strncmp

		 U strncpy

		 U strstr

		 U sysinfo

libcufft.so.3.0.14:

		 w _Jv_RegisterClasses

		 U _Unwind_Resume

		 U _ZTVN10__cxxabiv117__class_type_infoE

		 U _ZTVN10__cxxabiv120__si_class_type_infoE

		 U _ZdlPv

		 U _Znaj

		 U _Znwj

		 U __assert_fail

		 U __cudaRegisterFatBinary

		 U __cudaRegisterFunction

		 U __cudaRegisterShared

		 U __cudaRegisterTexture

		 U __cudaRegisterVar

		 U __cudaUnregisterFatBinary

		 U __cxa_atexit

		 w __cxa_finalize

		 U __cxa_pure_virtual

		 w __gmon_start__

		 U __gxx_personality_v0

		 w __isinf

		 w __isnan

		 U __strtol_internal

		 U abort

		 U calloc

		 w cos

		 U cudaBindTexture

		 U cudaConfigureCall

		 U cudaCreateChannelDesc

		 U cudaFree

		 U cudaFuncGetAttributes

		 U cudaGetDeviceProperties

		 U cudaGetLastError

		 U cudaLaunch

		 U cudaMalloc

		 U cudaMemcpyToSymbol

		 U cudaSetupArgument

		 U cudaUnbindTexture

00028b30 T cufftDestroy

000286a0 T cufftExecC2C

00028660 T cufftExecC2R

00028610 T cufftExecD2Z

00028680 T cufftExecR2C

000285f0 T cufftExecZ2D

00028630 T cufftExecZ2Z

00028ab0 T cufftPlan1d

00028a70 T cufftPlan2d

00028a20 T cufftPlan3d

00028980 T cufftPlanMany

00028c20 T cufftSetStream

		 U exit

		 w exp

		 w exp2

		 U fflush

		 U fileno

		 U fprintf

		 U free

		 U fwrite

		 U getenv

		 U log

		 w log1p

		 w log2

		 U malloc

		 U memalign

		 U memset

		 U pthread_getspecific

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 w remquo

		 w sin

		 U sqrt

		 U stderr

		 U stdout

		 U strcmp

		 U strcpy

		 U strlen

		 U vfprintf

libcufftemu.so.3.0.14:

		 w _Jv_RegisterClasses

		 U _Unwind_Resume

		 U _ZTVN10__cxxabiv117__class_type_infoE

		 U _ZTVN10__cxxabiv120__si_class_type_infoE

		 U _ZdlPv

		 U _Znaj

		 U _Znwj

		 U __assert_fail

		 U __cudaRegisterFatBinary

		 U __cudaRegisterFunction

		 U __cudaRegisterShared

		 U __cudaRegisterTexture

		 U __cudaRegisterVar

		 U __cudaSynchronizeThreads

		 U __cudaTextureFetch

		 U __cudaUnregisterFatBinary

		 U __cxa_atexit

		 w __cxa_finalize

		 U __cxa_pure_virtual

		 w __gmon_start__

		 U __gxx_personality_v0

		 w __isinf

		 w __isnan

		 U __strtol_internal

		 U abort

		 U calloc

		 w cos

		 w cosf

		 U cudaBindTexture

		 U cudaConfigureCall

		 U cudaCreateChannelDesc

		 U cudaFree

		 U cudaFuncGetAttributes

		 U cudaGetDeviceProperties

		 U cudaGetLastError

		 U cudaLaunch

		 U cudaMalloc

		 U cudaMemcpyToSymbol

		 U cudaSetupArgument

		 U cudaUnbindTexture

0004bcc0 T cufftDestroy

0004b870 T cufftExecC2C

0004b830 T cufftExecC2R

0004b7e0 T cufftExecD2Z

0004b850 T cufftExecR2C

0004b7c0 T cufftExecZ2D

0004b800 T cufftExecZ2Z

0004bc40 T cufftPlan1d

0004bc00 T cufftPlan2d

0004bbb0 T cufftPlan3d

0004bb10 T cufftPlanMany

0004bdb0 T cufftSetStream

		 U exit

		 w exp

		 w exp2

		 U fflush

		 U fileno

		 U fprintf

		 U free

		 U fwrite

		 U getenv

		 U log

		 w log1p

		 w log2

		 U malloc

		 U memalign

		 U memset

		 U pthread_getspecific

		 U pthread_key_create

		 U pthread_key_delete

		 U pthread_mutex_destroy

		 U pthread_mutex_init

		 U pthread_mutex_lock

		 U pthread_mutex_unlock

		 U pthread_mutexattr_init

		 U pthread_mutexattr_settype

		 U pthread_setspecific

		 U realloc

		 w remquo

		 w sin

		 w sinf

		 U sqrt

		 U stderr

		 U stdout

		 U strcmp

		 U strcpy

		 U strlen

		 U vfprintf

Vow! Never seen such a big post in my 2 years of experience with CUDA forums…