rocm-systems/rocclr/runtime/device/blitcl.cpp

//
// Copyright (c) 2010 Advanced Micro Devices, Inc. All rights reserved.
//

namespace device {

#define BLIT_KERNELS(...) #__VA_ARGS__

const char* BlitSourceCode = BLIT_KERNELS(

extern void __amd_copyBufferToImage(
    __global uint*, __write_only image2d_array_t, ulong4,
    int4, int4, uint4, ulong4);

extern void __amd_copyImageToBuffer(
    __read_only image2d_array_t, __global uint*, __global ushort*,
    __global uchar*, int4, ulong4, int4, uint4, ulong4);

extern void __amd_copyImage(
    __read_only image2d_array_t, __write_only image2d_array_t,
    int4, int4, int4);

extern void __amd_copyImage1DA(
    __read_only image2d_array_t, __write_only image2d_array_t,
    int4, int4, int4);

extern void __amd_copyBufferRect(
    __global uchar*, __global uchar*,
    ulong4, ulong4, ulong4);

extern void __amd_copyBufferRectAligned(
    __global uint*, __global uint*,
    ulong4, ulong4, ulong4);

extern void __amd_copyBuffer(
    __global uchar*, __global uchar*,
    ulong, ulong, ulong, uint);

extern void __amd_copyBufferAligned(
    __global uint*, __global uint*,
    ulong, ulong, ulong, uint);

extern void __amd_fillBuffer(
    __global uchar*, __global uint*, __constant uchar*,
    uint, ulong, ulong);

extern void __amd_fillImage(
    __write_only image2d_array_t,
    float4, int4, uint4, int4, int4, uint);


__kernel void copyBufferToImage(
    __global uint* src,
    __write_only image2d_array_t dst,
    ulong4 srcOrigin,
    int4 dstOrigin,
    int4 size,
    uint4 format,
    ulong4 pitch)
{
    __amd_copyBufferToImage(src, dst, srcOrigin, dstOrigin, size, format, pitch);
}

__kernel void copyImageToBuffer(
    __read_only image2d_array_t src,
    __global uint* dstUInt,
    __global ushort* dstUShort,
    __global uchar* dstUChar,
    int4 srcOrigin,
    ulong4 dstOrigin,
    int4 size,
    uint4 format,
    ulong4 pitch)
{
    __amd_copyImageToBuffer(src, dstUInt, dstUShort, dstUChar,
                              srcOrigin, dstOrigin, size, format, pitch);
}

__kernel void copyImage(
    __read_only  image2d_array_t src,
    __write_only image2d_array_t dst,
    int4 srcOrigin,
    int4 dstOrigin,
    int4 size)
{
    __amd_copyImage(src, dst, srcOrigin, dstOrigin, size);
}

__kernel void copyImage1DA(
    __read_only image2d_array_t src,
    __write_only image2d_array_t dst,
    int4 srcOrigin,
    int4 dstOrigin,
    int4 size)
{
    __amd_copyImage1DA(src, dst, srcOrigin, dstOrigin, size);
}

__kernel void copyBufferRect(
    __global uchar* src,
    __global uchar* dst,
    ulong4 srcRect,
    ulong4 dstRect,
    ulong4 size)
{
    __amd_copyBufferRect(src, dst, srcRect, dstRect, size);
}

__kernel void copyBufferRectAligned(
    __global uint* src,
    __global uint* dst,
    ulong4 srcRect,
    ulong4 dstRect,
    ulong4 size)
{
    __amd_copyBufferRectAligned(src, dst, srcRect, dstRect, size);
}

__kernel void copyBuffer(
    __global uchar* srcI,
    __global uchar* dstI,
    ulong srcOrigin,
    ulong dstOrigin,
    ulong size,
    uint remain)
{
    __amd_copyBuffer(srcI, dstI, srcOrigin, dstOrigin, size, remain);
}

__kernel void copyBufferAligned(
    __global uint* src,
    __global uint* dst,
    ulong srcOrigin,
    ulong dstOrigin,
    ulong size,
    uint alignment)
{
    __amd_copyBufferAligned(src, dst, srcOrigin, dstOrigin, size, alignment);
}

__kernel void fillBuffer(
    __global uchar* bufUChar,
    __global uint* bufUInt,
    __constant uchar* pattern,
    uint patternSize,
    ulong offset,
    ulong size)
{
    __amd_fillBuffer(bufUChar, bufUInt, pattern, patternSize, offset, size);
}

__kernel void fillImage(
    __write_only image2d_array_t image,
    float4 patternFLOAT4,
    int4 patternINT4,
    uint4 patternUINT4,
    int4 origin,
    int4 size,
    uint type)
{
    __amd_fillImage(image, patternFLOAT4, patternINT4, patternUINT4,
                      origin, size, type);
}

);

} // namespace device