diff --git a/api/hip/hip_device_runtime.cpp b/api/hip/hip_device_runtime.cpp
index 4d8ac9cec0..7c5c063ea6 100644
--- a/api/hip/hip_device_runtime.cpp
+++ b/api/hip/hip_device_runtime.cpp
@@ -401,14 +401,6 @@ hipError_t hipGetDeviceFlags ( unsigned int* flags ) {
   return hipErrorUnknown;
 }
 
-hipError_t hipIpcCloseMemHandle ( void* devPtr ) {
-  HIP_INIT_API(devPtr);
-
-  assert(0 && "Unimplemented");
-
-  return hipErrorUnknown;
-}
-
 hipError_t hipIpcGetEventHandle ( hipIpcEventHandle_t* handle, hipEvent_t event ) {
   HIP_INIT_API(handle, event);
 
@@ -417,14 +409,6 @@ hipError_t hipIpcGetEventHandle ( hipIpcEventHandle_t* handle, hipEvent_t event
   return hipErrorUnknown;
 }
 
-hipError_t hipIpcGetMemHandle ( hipIpcMemHandle_t* handle, void* devPtr ) {
-  HIP_INIT_API(handle, devPtr);
-
-  assert(0 && "Unimplemented");
-
-  return hipErrorUnknown;
-}
-
 hipError_t hipIpcOpenEventHandle ( hipEvent_t* event, hipIpcEventHandle_t handle ) {
   HIP_INIT_API(event, handle);
 
@@ -433,14 +417,6 @@ hipError_t hipIpcOpenEventHandle ( hipEvent_t* event, hipIpcEventHandle_t handle
   return hipErrorUnknown;
 }
 
-hipError_t hipIpcOpenMemHandle ( void** devPtr, hipIpcMemHandle_t handle, unsigned int  flags ) {
-  HIP_INIT_API(devPtr, handle, flags);
-
-  assert(0 && "Unimplemented");
-
-  return hipErrorUnknown;
-}
-
 hipError_t hipSetDevice ( int  device ) {
   HIP_INIT_API(device);
 
diff --git a/api/hip/hip_memory.cpp b/api/hip/hip_memory.cpp
index ddebc8623c..1fc000bf1d 100644
--- a/api/hip/hip_memory.cpp
+++ b/api/hip/hip_memory.cpp
@@ -91,20 +91,6 @@ hipError_t hipFree(void* ptr)
   return hipSuccess;
 }
 
-hipError_t hipMemcpyAsync(void* dst,
-                          const void* src,
-                          size_t sizeBytes,
-                          hipMemcpyKind kind,
-                          hipStream_t stream)
-{
-  HIP_INIT_API(dst, src, sizeBytes, kind, stream);
-
-  assert(0 && "Unimplemented");
-
-  return hipErrorUnknown;
-}
-
-
 hipError_t hipMemcpy(void* dst, const void* src, size_t sizeBytes, hipMemcpyKind kind)
 {
   HIP_INIT_API(dst, src, sizeBytes, kind);
@@ -182,3 +168,360 @@ hipError_t hipMemPtrGetInfo(void *ptr, size_t *size)
 
   return hipErrorUnknown;
 }
+
+hipError_t hipHostFree(void* ptr)
+{
+  HIP_INIT_API(ptr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipFreeArray(hipArray* array)
+{
+  HIP_INIT_API(array);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemGetAddressRange(hipDeviceptr_t* pbase, size_t* psize, hipDeviceptr_t dptr)
+{
+  HIP_INIT_API(pbase, psize, dptr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemGetInfo(size_t* free, size_t* total)
+{
+  HIP_INIT_API(free, total);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMallocPitch(void** ptr, size_t* pitch, size_t width, size_t height)
+{
+  HIP_INIT_API(ptr, pitch, width, height);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMalloc3D(hipPitchedPtr* pitchedDevPtr, hipExtent extent)
+{
+  HIP_INIT_API(pitchedDevPtr, &extent);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipArrayCreate(hipArray** array, const HIP_ARRAY_DESCRIPTOR* pAllocateArray)
+{
+  HIP_INIT_API(array, pAllocateArray);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMallocArray(hipArray** array, const hipChannelFormatDesc* desc,
+                          size_t width, size_t height, unsigned int flags)
+{
+  HIP_INIT_API(array, desc, width, height, flags);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMalloc3DArray(hipArray_t* array, const struct hipChannelFormatDesc* desc,
+                            struct hipExtent extent, unsigned int flags) 
+{
+  HIP_INIT_API(array, desc, &extent, flags);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipHostGetFlags(unsigned int* flagsPtr, void* hostPtr)
+{
+  HIP_INIT_API(flagsPtr, hostPtr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipHostRegister(void* hostPtr, size_t sizeBytes, unsigned int flags)
+{
+  HIP_INIT_API(hostPtr, sizeBytes, flags);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipHostUnregister(void* hostPtr)
+{
+  HIP_INIT_API(hostPtr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyToSymbol(const void* symbolName, const void* src, size_t count,
+                             size_t offset, hipMemcpyKind kind)
+{
+  HIP_INIT_API(symbolName, src, count, offset, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyFromSymbol(void* dst, const void* symbolName, size_t count,
+                               size_t offset, hipMemcpyKind kind)
+{
+  HIP_INIT_API(symbolName, dst, count, offset, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyToSymbolAsync(const void* symbolName, const void* src, size_t count,
+                                  size_t offset, hipMemcpyKind kind, hipStream_t stream)
+{
+  HIP_INIT_API(symbolName, src, count, offset, kind, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyFromSymbolAsync(void* dst, const void* symbolName, size_t count,
+                                    size_t offset, hipMemcpyKind kind, hipStream_t stream)
+{
+  HIP_INIT_API(symbolName, dst, count, offset, kind, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyHtoD(hipDeviceptr_t dst, void* src, size_t sizeBytes)
+{
+  HIP_INIT_API(dst, src, sizeBytes);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyDtoH(void* dst, hipDeviceptr_t src, size_t sizeBytes)
+{
+  HIP_INIT_API(dst, src, sizeBytes);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyDtoD(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes)
+{
+  HIP_INIT_API(dst, src, sizeBytes);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyHtoH(void* dst, void* src, size_t sizeBytes)
+{
+  HIP_INIT_API(dst, src, sizeBytes);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyAsync(void* dst, const void* src, size_t sizeBytes,
+                          hipMemcpyKind kind, hipStream_t stream)
+{
+  HIP_INIT_API(dst, src, sizeBytes, kind, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+
+hipError_t hipMemcpyHtoDAsync(hipDeviceptr_t dst, void* src, size_t sizeBytes,
+                              hipStream_t stream)
+{
+  HIP_INIT_API(dst, src, sizeBytes, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyDtoDAsync(hipDeviceptr_t dst, hipDeviceptr_t src, size_t sizeBytes,
+                              hipStream_t stream)
+{
+  HIP_INIT_API(dst, src, sizeBytes, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyDtoHAsync(void* dst, hipDeviceptr_t src, size_t sizeBytes,
+                              hipStream_t stream)
+{
+  HIP_INIT_API(dst, src, sizeBytes, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpy2D(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
+                       size_t height, hipMemcpyKind kind)
+{
+  HIP_INIT_API(dst, dpitch, src, spitch, width, height, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyParam2D(const hip_Memcpy2D* pCopy)
+{
+  HIP_INIT_API(pCopy);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpy2DAsync(void* dst, size_t dpitch, const void* src, size_t spitch, size_t width,
+                            size_t height, hipMemcpyKind kind, hipStream_t stream)
+{
+  HIP_INIT_API(dst, dpitch, src, spitch, width, height, kind, stream);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpy2DToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
+                              size_t spitch, size_t width, size_t height, hipMemcpyKind kind)
+{
+  HIP_INIT_API(dst, wOffset, hOffset, src, spitch, width, height, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyToArray(hipArray* dst, size_t wOffset, size_t hOffset, const void* src,
+                            size_t count, hipMemcpyKind kind)
+{
+  HIP_INIT_API(dst, wOffset, hOffset, src, count, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyFromArray(void* dst, hipArray_const_t srcArray, size_t wOffset, size_t hOffset,
+                              size_t count, hipMemcpyKind kind)
+{
+  HIP_INIT_API(dst, srcArray, wOffset, hOffset, count, kind);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyHtoA(hipArray* dstArray, size_t dstOffset, const void* srcHost, size_t count)
+{
+  HIP_INIT_API(dstArray, dstOffset, srcHost, count);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpyAtoH(void* dst, hipArray* srcArray, size_t srcOffset, size_t count)
+{
+  HIP_INIT_API(dst, srcArray, srcOffset, count);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemcpy3D(const struct hipMemcpy3DParms* p)
+{
+  HIP_INIT_API(p);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemset2D(void* dst, size_t pitch, int value, size_t width, size_t height)
+{
+  HIP_INIT_API(dst, pitch, value, width, height);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipMemsetD8(hipDeviceptr_t dst, unsigned char value, size_t sizeBytes)
+{
+  HIP_INIT_API(dst, value, sizeBytes);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipIpcGetMemHandle(hipIpcMemHandle_t* handle, void* devPtr)
+{
+  HIP_INIT_API(handle, devPtr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipIpcOpenMemHandle(void** devPtr, hipIpcMemHandle_t handle, unsigned int flags)
+{
+  HIP_INIT_API(devPtr, &handle, flags);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
+
+hipError_t hipIpcCloseMemHandle(void* devPtr) {
+  HIP_INIT_API(devPtr);
+
+  assert(0 && "Unimplemented");
+
+  return hipErrorUnknown;
+}
\ No newline at end of file