| /**************************************************************************** |
| * |
| * The MIT License (MIT) |
| * |
| * Copyright (c) 2014 - 2020 Vivante Corporation |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| ***************************************************************************** |
| * |
| * The GPL License (GPL) |
| * |
| * Copyright (C) 2014 - 2020 Vivante Corporation |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version 2 |
| * of the License, or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| * |
| ***************************************************************************** |
| * |
| * Note: This software is released under dual MIT and GPL licenses. A |
| * recipient may use this file under the terms of either the MIT license or |
| * GPL License. If you wish to use only one license not the other, you can |
| * indicate your decision by deleting one of the above license notices in your |
| * version of this file. |
| * |
| *****************************************************************************/ |
| |
| |
| #include "gc_hal_kernel_precomp.h" |
| #include <gc_hal_kernel_debug.h> |
| |
| /******************************************************************************\ |
| ******************************** Debug Variables ******************************* |
| \******************************************************************************/ |
| |
| static gceSTATUS _lastError = gcvSTATUS_OK; |
| static gctUINT32 _debugLevel = gcvLEVEL_ERROR; |
| /* |
| _debugZones config value |
| Please Reference define in gc_hal_base.h |
| */ |
| static gctUINT32 _debugZones = gcdZONE_NONE; |
| |
| /******************************************************************************\ |
| ********************************* Debug Switches ******************************* |
| \******************************************************************************/ |
| |
| /* |
| gcdTHREAD_BUFFERS |
| |
| When greater then one, will accumulate messages from the specified number |
| of threads in separate output buffers. |
| */ |
| #define gcdTHREAD_BUFFERS 1 |
| |
| /* |
| gcdSHOW_LINE_NUMBER |
| |
| When enabledm each print statement will be preceeded with the current |
| line number. |
| */ |
| #define gcdSHOW_LINE_NUMBER 0 |
| |
| /* |
| gcdSHOW_PROCESS_ID |
| |
| When enabledm each print statement will be preceeded with the current |
| process ID. |
| */ |
| #define gcdSHOW_PROCESS_ID 0 |
| |
| /* |
| gcdSHOW_THREAD_ID |
| |
| When enabledm each print statement will be preceeded with the current |
| thread ID. |
| */ |
| #define gcdSHOW_THREAD_ID 0 |
| |
| /* |
| gcdSHOW_TIME |
| |
| When enabled each print statement will be preceeded with the current |
| high-resolution time. |
| */ |
| #define gcdSHOW_TIME 0 |
| |
| |
| /******************************************************************************\ |
| ****************************** Miscellaneous Macros **************************** |
| \******************************************************************************/ |
| |
| #if gcdSHOW_TIME || gcdSHOW_LINE_NUMBER || gcdSHOW_PROCESS_ID || gcdSHOW_THREAD_ID |
| # define gcdHAVEPREFIX 1 |
| #else |
| # define gcdHAVEPREFIX 0 |
| #endif |
| |
| /******************************************************************************\ |
| ****************************** Private Structures ****************************** |
| \******************************************************************************/ |
| |
| typedef struct _gcsBUFFERED_OUTPUT * gcsBUFFERED_OUTPUT_PTR; |
| typedef struct _gcsBUFFERED_OUTPUT |
| { |
| #if gcdTHREAD_BUFFERS > 1 |
| gctUINT32 threadID; |
| #endif |
| |
| #if gcdSHOW_LINE_NUMBER |
| gctUINT lineNumber; |
| #endif |
| |
| gctINT indent; |
| |
| gcsBUFFERED_OUTPUT_PTR prev; |
| gcsBUFFERED_OUTPUT_PTR next; |
| } |
| gcsBUFFERED_OUTPUT; |
| |
| static gcsBUFFERED_OUTPUT _outputBuffer[gcdTHREAD_BUFFERS]; |
| static gcsBUFFERED_OUTPUT_PTR _outputBufferHead = gcvNULL; |
| static gcsBUFFERED_OUTPUT_PTR _outputBufferTail = gcvNULL; |
| |
| /******************************************************************************\ |
| ******************************* Printing Functions ***************************** |
| \******************************************************************************/ |
| |
| #if gcdHAVEPREFIX |
| |
| #if gcdSHOW_TIME |
| static gcmINLINE gctUINT64 |
| _GetTime( |
| void |
| ) |
| { |
| gctUINT64 time; |
| gckOS_GetProfileTick(&time); |
| return time; |
| } |
| # define gcdPREFIX_LEADER 1 |
| # define gcdTIMEFORMAT "%18lld" |
| # define gcdTIMEVALUE ,_GetTime() |
| # else |
| # define gcdTIMEFORMAT |
| # define gcdTIMEVALUE |
| # endif |
| |
| #if gcdSHOW_LINE_NUMBER |
| #ifndef gcdPREFIX_LEADER |
| # define gcdPREFIX_LEADER 1 |
| # define gcdNUMFORMAT "%8u" |
| # else |
| # define gcdNUMFORMAT ", %8u" |
| # endif |
| # define gcdNUMVALUE ,OutputBuffer->lineNumber |
| # else |
| # define gcdNUMFORMAT |
| # define gcdNUMVALUE |
| # endif |
| |
| #if gcdSHOW_PROCESS_ID |
| #ifndef gcdPREFIX_LEADER |
| # define gcdPREFIX_LEADER 1 |
| # define gcdPIDFORMAT "pid=%5u" |
| # else |
| # define gcdPIDFORMAT ", pid=%5u" |
| # endif |
| # define gcdPIDVALUE ,gcmkGETPROCESSID() |
| # else |
| # define gcdPIDFORMAT |
| # define gcdPIDVALUE |
| # endif |
| |
| #if gcdSHOW_THREAD_ID |
| #ifndef gcdPREFIX_LEADER |
| # define gcdPREFIX_LEADER 1 |
| # define gcdTIDFORMAT "tid=%5u" |
| # else |
| # define gcdTIDFORMAT ", tid=%5u" |
| # endif |
| # define gcdTIDVALUE ,gcmkGETTHREADID() |
| # else |
| # define gcdTIDFORMAT |
| # define gcdTIDVALUE |
| # endif |
| |
| static gctUINT |
| _PrintPrefix( |
| IN gcsBUFFERED_OUTPUT_PTR OutputBuffer, |
| IN char Buffer[], |
| IN gctUINT Size |
| ) |
| { |
| gctINT len; |
| |
| /* Format the string. */ |
| len = gcmkSPRINTF(Buffer, |
| Size, |
| "[" gcdTIMEFORMAT gcdNUMFORMAT gcdPIDFORMAT gcdTIDFORMAT "] " |
| gcdTIMEVALUE gcdNUMVALUE gcdPIDVALUE gcdTIDVALUE); |
| |
| if (len > 0) |
| { |
| Buffer[len] = '\0'; |
| return (gctUINT)len; |
| } |
| |
| return 0; |
| } |
| #endif |
| |
| static int |
| _AppendIndent( |
| IN gctINT Indent, |
| IN char * Buffer, |
| IN int BufferSize |
| ) |
| { |
| gctINT i; |
| |
| gctINT len = 0; |
| gctINT indent = Indent % 40; |
| |
| for (i = 0; i < indent; i += 1) |
| { |
| Buffer[len++] = ' '; |
| } |
| |
| if (indent != Indent) |
| { |
| len += gcmkSPRINTF( |
| Buffer + len, BufferSize - len, " <%d> ", Indent |
| ); |
| |
| Buffer[len] = '\0'; |
| } |
| |
| return len; |
| } |
| |
| static gctUINT |
| _PrintString( |
| IN gcsBUFFERED_OUTPUT_PTR OutputBuffer, |
| IN gctINT Indent, |
| IN gctCONST_STRING Message, |
| IN gctPOINTER Data, |
| IN char Buffer[], |
| IN gctUINT Size |
| ) |
| { |
| gctINT len; |
| |
| /* Append the indent string. */ |
| len = _AppendIndent(Indent, Buffer, Size); |
| |
| /* Format the string. */ |
| len += gcmkVSPRINTF(Buffer + len, Size - len, Message, Data); |
| Buffer[len] = '\0'; |
| |
| /* Add end-of-line if missing. */ |
| if (Buffer[len - 1] != '\n') |
| { |
| Buffer[len++] = '\n'; |
| Buffer[len] = '\0'; |
| } |
| |
| return (gctUINT)len; |
| } |
| |
| /******************************************************************************\ |
| ******************************* Private Functions ****************************** |
| \******************************************************************************/ |
| |
| static gcmINLINE void |
| _InitBuffers( |
| void |
| ) |
| { |
| int i; |
| |
| if (_outputBufferHead == gcvNULL) |
| { |
| for (i = 0; i < gcdTHREAD_BUFFERS; i += 1) |
| { |
| if (_outputBufferTail == gcvNULL) |
| { |
| _outputBufferHead = &_outputBuffer[i]; |
| } |
| else |
| { |
| _outputBufferTail->next = &_outputBuffer[i]; |
| } |
| |
| #if gcdTHREAD_BUFFERS > 1 |
| _outputBuffer[i].threadID = ~0U; |
| #endif |
| |
| _outputBuffer[i].prev = _outputBufferTail; |
| _outputBuffer[i].next = gcvNULL; |
| |
| _outputBufferTail = &_outputBuffer[i]; |
| } |
| } |
| } |
| |
| static gcmINLINE gcsBUFFERED_OUTPUT_PTR |
| _GetOutputBuffer( |
| void |
| ) |
| { |
| gcsBUFFERED_OUTPUT_PTR outputBuffer; |
| |
| #if gcdTHREAD_BUFFERS > 1 |
| /* Get the current thread ID. */ |
| gctUINT32 ThreadID = gcmkGETTHREADID(); |
| |
| /* Locate the output buffer for the thread. */ |
| outputBuffer = _outputBufferHead; |
| |
| while (outputBuffer != gcvNULL) |
| { |
| if (outputBuffer->threadID == ThreadID) |
| { |
| break; |
| } |
| |
| outputBuffer = outputBuffer->next; |
| } |
| |
| /* No matching buffer found? */ |
| if (outputBuffer == gcvNULL) |
| { |
| /* Get the tail for the buffer. */ |
| outputBuffer = _outputBufferTail; |
| |
| /* Move it to the head. */ |
| _outputBufferTail = _outputBufferTail->prev; |
| _outputBufferTail->next = gcvNULL; |
| |
| outputBuffer->prev = gcvNULL; |
| outputBuffer->next = _outputBufferHead; |
| |
| _outputBufferHead->prev = outputBuffer; |
| _outputBufferHead = outputBuffer; |
| |
| /* Reset the buffer. */ |
| outputBuffer->threadID = ThreadID; |
| #if gcdSHOW_LINE_NUMBER |
| outputBuffer->lineNumber = 0; |
| # endif |
| } |
| #else |
| outputBuffer = _outputBufferHead; |
| #endif |
| |
| return outputBuffer; |
| } |
| |
| static void |
| _Print( |
| IN gctCONST_STRING Message, |
| IN gctARGUMENTS * Arguments |
| ) |
| { |
| gcsBUFFERED_OUTPUT_PTR outputBuffer; |
| char buffer[256]; |
| char *ptr = buffer; |
| gctINT len = 0; |
| static gcmkDECLARE_MUTEX(printMutex); |
| |
| gcmkMUTEX_LOCK(printMutex); |
| |
| /* Initialize output buffer list. */ |
| _InitBuffers(); |
| |
| /* Locate the proper output buffer. */ |
| outputBuffer = _GetOutputBuffer(); |
| |
| /* Print prefix. */ |
| #if gcdHAVEPREFIX |
| #if gcdSHOW_LINE_NUMBER |
| /* Update the line number. */ |
| outputBuffer->lineNumber += 1; |
| # endif |
| |
| /* Print the prefix. */ |
| len = _PrintPrefix(outputBuffer, buffer, gcmSIZEOF(buffer)); |
| ptr += len; |
| #endif |
| |
| /* Form the indent string. */ |
| if (Message[0] == '-' && Message[1] == '-') |
| { |
| outputBuffer->indent -= 2; |
| } |
| |
| /* Print the message. */ |
| len += _PrintString( |
| outputBuffer, outputBuffer->indent, |
| Message, ((gctPOINTER) Arguments), |
| ptr, gcmSIZEOF(buffer) - outputBuffer->indent - len |
| ); |
| |
| gcmkOUTPUT_STRING(buffer); |
| |
| /* Check increasing indent. */ |
| if (Message[0] == '+' && Message[1] == '+') |
| { |
| outputBuffer->indent += 2; |
| } |
| |
| gcmkMUTEX_UNLOCK(printMutex); |
| } |
| |
| |
| /******************************************************************************\ |
| ********************************* Debug Macros ********************************* |
| \******************************************************************************/ |
| |
| #ifdef __QNXNTO__ |
| |
| extern volatile unsigned g_nQnxInIsrs; |
| |
| #define gcmDEBUGPRINT(Message) \ |
| { \ |
| if (atomic_add_value(&g_nQnxInIsrs, 1) == 0) \ |
| { \ |
| gctARGUMENTS __arguments__; \ |
| gcmkARGUMENTS_START(__arguments__, Message); \ |
| _Print(Message, &__arguments__); \ |
| gcmkARGUMENTS_END(__arguments__); \ |
| } \ |
| atomic_sub(&g_nQnxInIsrs, 1); \ |
| } |
| |
| #elif defined(__VXWORKS__) |
| #define gcmDEBUGPRINT(Message) \ |
| { \ |
| printf(Message); \ |
| } |
| |
| #else |
| |
| #define gcmDEBUGPRINT(Message) \ |
| { \ |
| gctARGUMENTS __arguments__; \ |
| gcmkARGUMENTS_START(__arguments__, Message); \ |
| _Print(Message, &__arguments__); \ |
| gcmkARGUMENTS_END(__arguments__); \ |
| } |
| |
| #endif |
| |
| /******************************************************************************\ |
| ********************************** Debug Code ********************************** |
| \******************************************************************************/ |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_Print |
| ** |
| ** Send a message to the debugger. |
| ** |
| ** INPUT: |
| ** |
| ** gctCONST_STRING Message |
| ** Pointer to message. |
| ** |
| ** ... |
| ** Optional arguments. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_Print( |
| IN gctCONST_STRING Message, |
| ... |
| ) |
| { |
| gcmDEBUGPRINT(Message); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_DebugTrace |
| ** |
| ** Send a leveled message to the debugger. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Level |
| ** Debug level of message. |
| ** |
| ** gctCONST_STRING Message |
| ** Pointer to message. |
| ** |
| ** ... |
| ** Optional arguments. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_DebugTrace( |
| IN gctUINT32 Level, |
| IN gctCONST_STRING Message, |
| ... |
| ) |
| { |
| if (Level > _debugLevel) |
| { |
| return; |
| } |
| |
| gcmDEBUGPRINT(Message); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_DebugTraceZone |
| ** |
| ** Send a leveled and zoned message to the debugger. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Level |
| ** Debug level for message. |
| ** |
| ** gctUINT32 Zone |
| ** Debug zone for message. |
| ** |
| ** gctCONST_STRING Message |
| ** Pointer to message. |
| ** |
| ** ... |
| ** Optional arguments. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_DebugTraceZone( |
| IN gctUINT32 Level, |
| IN gctUINT32 Zone, |
| IN gctCONST_STRING Message, |
| ... |
| ) |
| { |
| if ((Level > _debugLevel) || !(Zone & _debugZones)) |
| { |
| return; |
| } |
| |
| gcmDEBUGPRINT(Message); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_DebugBreak |
| ** |
| ** Break into the debugger. |
| ** |
| ** INPUT: |
| ** |
| ** Nothing. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| void |
| gckOS_DebugBreak( |
| void |
| ) |
| { |
| gckOS_DebugTrace(gcvLEVEL_ERROR, "%s(%d)", __FUNCTION__, __LINE__); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_DebugFatal |
| ** |
| ** Send a message to the debugger and break into the debugger. |
| ** |
| ** INPUT: |
| ** |
| ** gctCONST_STRING Message |
| ** Pointer to message. |
| ** |
| ** ... |
| ** Optional arguments. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| void |
| gckOS_DebugFatal( |
| IN gctCONST_STRING Message, |
| ... |
| ) |
| { |
| gcmkPRINT_VERSION(); |
| gcmDEBUGPRINT(Message); |
| |
| /* Break into the debugger. */ |
| gckOS_DebugBreak(); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_SetDebugLevel |
| ** |
| ** Set the debug level. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Level |
| ** New debug level. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_SetDebugLevel( |
| IN gctUINT32 Level |
| ) |
| { |
| _debugLevel = Level; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_SetDebugZone |
| ** |
| ** Set the debug zone. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Zone |
| ** New debug zone. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| void |
| gckOS_SetDebugZone( |
| IN gctUINT32 Zone |
| ) |
| { |
| _debugZones = Zone; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_SetDebugLevelZone |
| ** |
| ** Set the debug level and zone. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Level |
| ** New debug level. |
| ** |
| ** gctUINT32 Zone |
| ** New debug zone. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_SetDebugLevelZone( |
| IN gctUINT32 Level, |
| IN gctUINT32 Zone |
| ) |
| { |
| _debugLevel = Level; |
| _debugZones = Zone; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_SetDebugZones |
| ** |
| ** Enable or disable debug zones. |
| ** |
| ** INPUT: |
| ** |
| ** gctUINT32 Zones |
| ** Debug zones to enable or disable. |
| ** |
| ** gctBOOL Enable |
| ** Set to gcvTRUE to enable the zones (or the Zones with the current |
| ** zones) or gcvFALSE to disable the specified Zones. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_SetDebugZones( |
| IN gctUINT32 Zones, |
| IN gctBOOL Enable |
| ) |
| { |
| if (Enable) |
| { |
| /* Enable the zones. */ |
| _debugZones |= Zones; |
| } |
| else |
| { |
| /* Disable the zones. */ |
| _debugZones &= ~Zones; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_Verify |
| ** |
| ** Called to verify the result of a function call. |
| ** |
| ** INPUT: |
| ** |
| ** gceSTATUS Status |
| ** Function call result. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| |
| void |
| gckOS_Verify( |
| IN gceSTATUS status |
| ) |
| { |
| _lastError = status; |
| } |
| |
| gctCONST_STRING |
| gckOS_DebugStatus2Name( |
| gceSTATUS status |
| ) |
| { |
| switch (status) |
| { |
| case gcvSTATUS_OK: |
| return "gcvSTATUS_OK"; |
| case gcvSTATUS_TRUE: |
| return "gcvSTATUS_TRUE"; |
| case gcvSTATUS_NO_MORE_DATA: |
| return "gcvSTATUS_NO_MORE_DATA"; |
| case gcvSTATUS_CACHED: |
| return "gcvSTATUS_CACHED"; |
| case gcvSTATUS_MIPMAP_TOO_LARGE: |
| return "gcvSTATUS_MIPMAP_TOO_LARGE"; |
| case gcvSTATUS_NAME_NOT_FOUND: |
| return "gcvSTATUS_NAME_NOT_FOUND"; |
| case gcvSTATUS_NOT_OUR_INTERRUPT: |
| return "gcvSTATUS_NOT_OUR_INTERRUPT"; |
| case gcvSTATUS_MISMATCH: |
| return "gcvSTATUS_MISMATCH"; |
| case gcvSTATUS_MIPMAP_TOO_SMALL: |
| return "gcvSTATUS_MIPMAP_TOO_SMALL"; |
| case gcvSTATUS_LARGER: |
| return "gcvSTATUS_LARGER"; |
| case gcvSTATUS_SMALLER: |
| return "gcvSTATUS_SMALLER"; |
| case gcvSTATUS_CHIP_NOT_READY: |
| return "gcvSTATUS_CHIP_NOT_READY"; |
| case gcvSTATUS_NEED_CONVERSION: |
| return "gcvSTATUS_NEED_CONVERSION"; |
| case gcvSTATUS_SKIP: |
| return "gcvSTATUS_SKIP"; |
| case gcvSTATUS_DATA_TOO_LARGE: |
| return "gcvSTATUS_DATA_TOO_LARGE"; |
| case gcvSTATUS_INVALID_CONFIG: |
| return "gcvSTATUS_INVALID_CONFIG"; |
| case gcvSTATUS_CHANGED: |
| return "gcvSTATUS_CHANGED"; |
| case gcvSTATUS_NOT_SUPPORT_DITHER: |
| return "gcvSTATUS_NOT_SUPPORT_DITHER"; |
| |
| case gcvSTATUS_INVALID_ARGUMENT: |
| return "gcvSTATUS_INVALID_ARGUMENT"; |
| case gcvSTATUS_INVALID_OBJECT: |
| return "gcvSTATUS_INVALID_OBJECT"; |
| case gcvSTATUS_OUT_OF_MEMORY: |
| return "gcvSTATUS_OUT_OF_MEMORY"; |
| case gcvSTATUS_MEMORY_LOCKED: |
| return "gcvSTATUS_MEMORY_LOCKED"; |
| case gcvSTATUS_MEMORY_UNLOCKED: |
| return "gcvSTATUS_MEMORY_UNLOCKED"; |
| case gcvSTATUS_HEAP_CORRUPTED: |
| return "gcvSTATUS_HEAP_CORRUPTED"; |
| case gcvSTATUS_GENERIC_IO: |
| return "gcvSTATUS_GENERIC_IO"; |
| case gcvSTATUS_INVALID_ADDRESS: |
| return "gcvSTATUS_INVALID_ADDRESS"; |
| case gcvSTATUS_CONTEXT_LOSSED: |
| return "gcvSTATUS_CONTEXT_LOSSED"; |
| case gcvSTATUS_TOO_COMPLEX: |
| return "gcvSTATUS_TOO_COMPLEX"; |
| case gcvSTATUS_BUFFER_TOO_SMALL: |
| return "gcvSTATUS_BUFFER_TOO_SMALL"; |
| case gcvSTATUS_INTERFACE_ERROR: |
| return "gcvSTATUS_INTERFACE_ERROR"; |
| case gcvSTATUS_NOT_SUPPORTED: |
| return "gcvSTATUS_NOT_SUPPORTED"; |
| case gcvSTATUS_MORE_DATA: |
| return "gcvSTATUS_MORE_DATA"; |
| case gcvSTATUS_TIMEOUT: |
| return "gcvSTATUS_TIMEOUT"; |
| case gcvSTATUS_OUT_OF_RESOURCES: |
| return "gcvSTATUS_OUT_OF_RESOURCES"; |
| case gcvSTATUS_INVALID_DATA: |
| return "gcvSTATUS_INVALID_DATA"; |
| case gcvSTATUS_INVALID_MIPMAP: |
| return "gcvSTATUS_INVALID_MIPMAP"; |
| case gcvSTATUS_NOT_FOUND: |
| return "gcvSTATUS_NOT_FOUND"; |
| case gcvSTATUS_NOT_ALIGNED: |
| return "gcvSTATUS_NOT_ALIGNED"; |
| case gcvSTATUS_INVALID_REQUEST: |
| return "gcvSTATUS_INVALID_REQUEST"; |
| case gcvSTATUS_GPU_NOT_RESPONDING: |
| return "gcvSTATUS_GPU_NOT_RESPONDING"; |
| case gcvSTATUS_TIMER_OVERFLOW: |
| return "gcvSTATUS_TIMER_OVERFLOW"; |
| case gcvSTATUS_VERSION_MISMATCH: |
| return "gcvSTATUS_VERSION_MISMATCH"; |
| case gcvSTATUS_LOCKED: |
| return "gcvSTATUS_LOCKED"; |
| case gcvSTATUS_INTERRUPTED: |
| return "gcvSTATUS_INTERRUPTED"; |
| case gcvSTATUS_DEVICE: |
| return "gcvSTATUS_DEVICE"; |
| case gcvSTATUS_NOT_MULTI_PIPE_ALIGNED: |
| return "gcvSTATUS_NOT_MULTI_PIPE_ALIGNED"; |
| |
| /* Linker errors. */ |
| case gcvSTATUS_GLOBAL_TYPE_MISMATCH: |
| return "gcvSTATUS_GLOBAL_TYPE_MISMATCH"; |
| case gcvSTATUS_TOO_MANY_ATTRIBUTES: |
| return "gcvSTATUS_TOO_MANY_ATTRIBUTES"; |
| case gcvSTATUS_TOO_MANY_UNIFORMS: |
| return "gcvSTATUS_TOO_MANY_UNIFORMS"; |
| case gcvSTATUS_TOO_MANY_VARYINGS: |
| return "gcvSTATUS_TOO_MANY_VARYINGS"; |
| case gcvSTATUS_UNDECLARED_VARYING: |
| return "gcvSTATUS_UNDECLARED_VARYING"; |
| case gcvSTATUS_VARYING_TYPE_MISMATCH: |
| return "gcvSTATUS_VARYING_TYPE_MISMATCH"; |
| case gcvSTATUS_MISSING_MAIN: |
| return "gcvSTATUS_MISSING_MAIN"; |
| case gcvSTATUS_NAME_MISMATCH: |
| return "gcvSTATUS_NAME_MISMATCH"; |
| case gcvSTATUS_INVALID_INDEX: |
| return "gcvSTATUS_INVALID_INDEX"; |
| case gcvSTATUS_UNIFORM_MISMATCH: |
| return "gcvSTATUS_UNIFORM_MISMATCH"; |
| case gcvSTATUS_UNSAT_LIB_SYMBOL: |
| return "gcvSTATUS_UNSAT_LIB_SYMBOL"; |
| case gcvSTATUS_TOO_MANY_SHADERS: |
| return "gcvSTATUS_TOO_MANY_SHADERS"; |
| case gcvSTATUS_LINK_INVALID_SHADERS: |
| return "gcvSTATUS_LINK_INVALID_SHADERS"; |
| case gcvSTATUS_CS_NO_WORKGROUP_SIZE: |
| return "gcvSTATUS_CS_NO_WORKGROUP_SIZE"; |
| case gcvSTATUS_LINK_LIB_ERROR: |
| return "gcvSTATUS_LINK_LIB_ERROR"; |
| case gcvSTATUS_SHADER_VERSION_MISMATCH: |
| return "gcvSTATUS_SHADER_VERSION_MISMATCH"; |
| case gcvSTATUS_TOO_MANY_INSTRUCTION: |
| return "gcvSTATUS_TOO_MANY_INSTRUCTION"; |
| case gcvSTATUS_SSBO_MISMATCH: |
| return "gcvSTATUS_SSBO_MISMATCH"; |
| case gcvSTATUS_TOO_MANY_OUTPUT: |
| return "gcvSTATUS_TOO_MANY_OUTPUT"; |
| case gcvSTATUS_TOO_MANY_INPUT: |
| return "gcvSTATUS_TOO_MANY_INPUT"; |
| case gcvSTATUS_NOT_SUPPORT_CL: |
| return "gcvSTATUS_NOT_SUPPORT_CL"; |
| case gcvSTATUS_NOT_SUPPORT_INTEGER: |
| return "gcvSTATUS_NOT_SUPPORT_INTEGER"; |
| case gcvSTATUS_UNIFORM_TYPE_MISMATCH: |
| return "gcvSTATUS_UNIFORM_TYPE_MISMATCH"; |
| case gcvSTATUS_MISSING_PRIMITIVE_TYPE: |
| return "gcvSTATUS_MISSING_PRIMITIVE_TYPE"; |
| case gcvSTATUS_MISSING_OUTPUT_VERTEX_COUNT: |
| return "gcvSTATUS_MISSING_OUTPUT_VERTEX_COUNT"; |
| case gcvSTATUS_NON_INVOCATION_ID_AS_INDEX: |
| return "gcvSTATUS_NON_INVOCATION_ID_AS_INDEX"; |
| case gcvSTATUS_INPUT_ARRAY_SIZE_MISMATCH: |
| return "gcvSTATUS_INPUT_ARRAY_SIZE_MISMATCH"; |
| case gcvSTATUS_OUTPUT_ARRAY_SIZE_MISMATCH: |
| return "gcvSTATUS_OUTPUT_ARRAY_SIZE_MISMATCH"; |
| |
| /* Compiler errors. */ |
| case gcvSTATUS_COMPILER_FE_PREPROCESSOR_ERROR: |
| return "gcvSTATUS_COMPILER_FE_PREPROCESSOR_ERROR"; |
| case gcvSTATUS_COMPILER_FE_PARSER_ERROR: |
| return "gcvSTATUS_COMPILER_FE_PARSER_ERROR"; |
| default: |
| return "nil"; |
| } |
| } |
| |
| /******************************************************************************* |
| ***** Kernel Dump ************************************************************** |
| *******************************************************************************/ |
| |
| /* |
| * TODO: Dump to file is only valid in linux currently. |
| */ |
| #ifndef gcmkDUMP_STRING |
| # define gcmkDUMP_STRING(os, s) gcmkOUTPUT_STRING((s)) |
| #endif |
| |
| static gcmkDECLARE_MUTEX(_dumpMutex); |
| static gctCHAR _dumpStorage[512]; |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_Dump |
| ** |
| ** Formated print string to dump pool. |
| ** |
| ** INPUT: |
| ** |
| ** gctCONST_STRING Format |
| ** String format. |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| void |
| gckOS_Dump( |
| IN gckOS Os, |
| IN gctCONST_STRING Format, |
| ... |
| ) |
| { |
| char buffer[256]; |
| gctINT len; |
| gctARGUMENTS args; |
| |
| gcmkARGUMENTS_START(args, Format); |
| len = gcmkVSPRINTF(buffer, gcmSIZEOF(buffer) - 2, Format, &args); |
| gcmkARGUMENTS_END(args); |
| |
| if (len > 0) |
| { |
| if (buffer[len - 1] != '\n') |
| { |
| buffer[len] = '\n'; |
| buffer[len + 1] = '\0'; |
| } |
| |
| gcmkMUTEX_LOCK(_dumpMutex); |
| gcmkDUMP_STRING(Os, buffer); |
| gcmkMUTEX_UNLOCK(_dumpMutex); |
| } |
| } |
| |
| static void |
| _DumpUserString( |
| IN gckOS Os, |
| IN gctPOINTER UserStr, |
| IN gctSIZE_T Size |
| ) |
| { |
| gceSTATUS status = gcvSTATUS_OK; |
| gctSIZE_T offset = 0; |
| gctSIZE_T length = 0; |
| gctBOOL needCopy = gcvTRUE; |
| const gctSIZE_T maxLength = gcmSIZEOF(_dumpStorage) - 1; |
| |
| gcmkVERIFY_OK(gckOS_QueryNeedCopy(Os, 0, &needCopy)); |
| |
| gcmkMUTEX_LOCK(_dumpMutex); |
| |
| while (offset < Size) |
| { |
| length = maxLength < (Size - offset) ? maxLength : (Size - offset); |
| |
| /* Copy or map from user. */ |
| if (needCopy) |
| { |
| gcmkONERROR(gckOS_CopyFromUserData( |
| Os, |
| _dumpStorage, |
| UserStr, |
| length |
| )); |
| } |
| else |
| { |
| gctPOINTER ptr = gcvNULL; |
| |
| gcmkONERROR(gckOS_MapUserPointer( |
| Os, |
| UserStr, |
| length, |
| (gctPOINTER *)&ptr |
| )); |
| |
| gckOS_MemCopy(_dumpStorage, ptr, length); |
| gckOS_UnmapUserPointer(Os, UserStr, length, ptr); |
| } |
| |
| _dumpStorage[length] = '\0'; |
| gcmkDUMP_STRING(Os, _dumpStorage); |
| |
| UserStr = (gctUINT8_PTR)UserStr + length; |
| offset += length; |
| } |
| |
| gcmkDUMP_STRING(Os, "\n"); |
| |
| OnError: |
| gcmkMUTEX_UNLOCK(_dumpMutex); |
| } |
| |
| static void |
| _DumpDataBuffer( |
| IN gckOS Os, |
| IN gceDUMP_BUFFER_TYPE Type, |
| IN gctPOINTER Data, |
| IN gctUINT64 Address, |
| IN gctSIZE_T Size |
| ) |
| { |
| gceSTATUS status = gcvSTATUS_OK; |
| gctSIZE_T offset = 0; |
| gctSIZE_T length = 0; |
| gctBOOL needCopy = gcvTRUE; |
| gctCONST_STRING dumpTag; |
| char buffer[256]; |
| const gctSIZE_T maxLength = gcmSIZEOF(_dumpStorage); |
| |
| switch (Type) |
| { |
| case gcvDUMP_BUFFER_VERIFY: |
| dumpTag = "verify"; |
| break; |
| case gcvDUMP_BUFFER_PHYSICAL_MEMORY: |
| dumpTag = "physical"; |
| break; |
| default: |
| dumpTag = "memory"; |
| break; |
| } |
| |
| if (Type <= gcvDUMP_BUFFER_USER_TYPE_LAST) |
| { |
| gcmkVERIFY_OK(gckOS_QueryNeedCopy(Os, 0, &needCopy)); |
| } |
| |
| gcmkMUTEX_LOCK(_dumpMutex); |
| |
| /* Form and print the opening string. */ |
| if (Type == gcvDUMP_BUFFER_PHYSICAL_MEMORY) |
| { |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| "@[%s 0x%010llX 0x%08X\n", |
| dumpTag, (unsigned long long)Address, (gctUINT32)Size); |
| } |
| else |
| { |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| "@[%s 0x%08X 0x%08X\n", |
| dumpTag, (gctUINT32)Address, (gctUINT32)Size); |
| } |
| |
| gcmkDUMP_STRING(Os, buffer); |
| |
| |
| while (offset < Size) |
| { |
| gctPOINTER data = gcvNULL; |
| gctUINT32_PTR ptr; |
| gctUINT8_PTR bytePtr; |
| gctSIZE_T count, tailByteCount; |
| |
| length = maxLength < (Size - offset) ? maxLength : (Size - offset); |
| count = length / 4; |
| tailByteCount = length % 4; |
| |
| ptr = (gctUINT32_PTR)Data; |
| |
| if (Type <= gcvDUMP_BUFFER_USER_TYPE_LAST) |
| { |
| /* Copy or map from user. */ |
| if (needCopy) |
| { |
| gcmkONERROR(gckOS_CopyFromUserData( |
| Os, |
| _dumpStorage, |
| Data, |
| length |
| )); |
| |
| ptr = (gctUINT32_PTR)_dumpStorage; |
| } |
| else |
| { |
| gcmkONERROR(gckOS_MapUserPointer( |
| Os, |
| Data, |
| length, |
| (gctPOINTER *)&data |
| )); |
| |
| ptr = (gctUINT32_PTR)data; |
| } |
| } |
| |
| while (count >= 4) |
| { |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x%08X 0x%08X 0x%08X 0x%08X\n", |
| ptr[0], ptr[1], ptr[2], ptr[3]); |
| |
| ptr += 4; |
| count -= 4; |
| |
| gcmkDUMP_STRING(Os, buffer); |
| } |
| |
| switch (count) |
| { |
| case 3: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x%08X 0x%08X 0x%08X", |
| ptr[0], ptr[1], ptr[2]); |
| break; |
| case 2: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x%08X 0x%08X", |
| ptr[0], ptr[1]); |
| break; |
| case 1: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, " 0x%08X", ptr[0]); |
| break; |
| } |
| |
| if (count > 0) |
| { |
| gcmkDUMP_STRING(Os, buffer); |
| } |
| |
| bytePtr = (gctUINT8_PTR)(ptr + count); |
| |
| if (!count && tailByteCount) |
| { |
| /* There is an extra space for the new line. */ |
| gcmkDUMP_STRING(Os, " "); |
| } |
| |
| switch (tailByteCount) |
| { |
| case 3: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x00%02X%02X%02X", |
| bytePtr[2], bytePtr[1], bytePtr[0]); |
| break; |
| case 2: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x0000%02X%02X", |
| bytePtr[1], bytePtr[0]); |
| break; |
| case 1: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, |
| " 0x000000%02X", bytePtr[0]); |
| break; |
| } |
| |
| if (tailByteCount) |
| { |
| gcmkDUMP_STRING(Os, buffer); |
| } |
| |
| if (count || tailByteCount) |
| { |
| gcmkDUMP_STRING(Os, "\n"); |
| } |
| |
| if (Type <= gcvDUMP_BUFFER_USER_TYPE_LAST && !needCopy) |
| { |
| gckOS_UnmapUserPointer(Os, Data, length, data); |
| } |
| /* advance to next batch. */ |
| Data = (gctUINT8_PTR)Data + length; |
| offset += length; |
| } |
| |
| OnError: |
| gcmkSPRINTF(buffer, gcmSIZEOF(buffer) - 1, "] -- %s\n", dumpTag); |
| gcmkDUMP_STRING(Os, buffer); |
| |
| gcmkMUTEX_UNLOCK(_dumpMutex); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** gckOS_DumpBuffer |
| ** |
| ** Print the contents of the specified buffer. |
| ** |
| ** INPUT: |
| ** |
| ** gckOS Os |
| ** Pointer to gckOS object. |
| ** |
| ** gceDUMP_BUFFER_TYPE Type |
| ** Buffer type. |
| ** |
| ** gctPOINTER Buffer |
| ** Pointer to the buffer to print. |
| ** |
| ** gctUINT64 Address |
| ** Address. |
| ** |
| ** gctUINT Size |
| ** Size of the buffer. |
| ** |
| ** |
| ** OUTPUT: |
| ** |
| ** Nothing. |
| */ |
| void |
| gckOS_DumpBuffer( |
| IN gckOS Os, |
| IN gceDUMP_BUFFER_TYPE Type, |
| IN gctPOINTER Buffer, |
| IN gctUINT64 Address, |
| IN gctSIZE_T Size |
| ) |
| { |
| if (!Buffer) |
| { |
| return; |
| } |
| |
| /* memory dump below. */ |
| if (Type >= gcvDUMP_BUFFER_TYPE_COUNT) |
| { |
| gcmkPRINT("#[ERROR: invalid buffer type]\n"); |
| return; |
| } |
| |
| if (Type == gcvDUMP_BUFFER_USER_STRING) |
| { |
| _DumpUserString(Os, Buffer, Size); |
| } |
| else |
| { |
| _DumpDataBuffer(Os, Type, Buffer, Address, Size); |
| } |
| } |
| |
| |
| /******************************************************************************* |
| ***** Binary Trace ************************************************************* |
| *******************************************************************************/ |
| |
