/* * Copyright (c) 2017, Intel 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. */ //! //! \file cm_printf_host.cpp //! \brief Contains Class PFParser definitions //! #include "cm_printf_host.h" #if CM_KERNEL_PRINTF_ON #include "cm_debug.h" void PFParser::getToken(void) { mPrevToken = mCurrToken; mCurrToken = Token(); // This is a lexer that has 2 modes // Inside a conversion specification and outside while (*mCurrLoc != '\0') { if (!mInSpec) { // We're just picking off characters until we see a % mCurrToken.mTokenType = Token::String; while (*mCurrLoc != '\0') { if (*mCurrLoc == '%') { // Peek to check for %% if (*(mCurrLoc+1) != '\0' && *(mCurrLoc+1) != '%') { // This is definitely a directive, not a %% break; } // This IS %% so take another character off the input mCurrToken.mTokenString += *mCurrLoc++; } mCurrToken.mTokenString += *mCurrLoc++; } if (*mCurrLoc == '%') mInSpec = true; if (mCurrToken.mTokenString.length() > 0) return; } if (mInSpec) { char currChar = *mCurrLoc++; switch(currChar) { default: // We've had an unexpected character mCurrToken.mTokenType = Token::Error; mCurrToken.mTokenString += currChar; // Preserve the error char mInSpec = false; // End of the format spec return; case '%': mCurrToken.mTokenType = Token::Percent; return; case '-': mCurrToken.mTokenType = Token::Minus; return; case '+': mCurrToken.mTokenType = Token::Plus; return; case ' ': mCurrToken.mTokenType = Token::Space; return; case '.': mCurrToken.mTokenType = Token::Period; return; case '#': mCurrToken.mTokenType = Token::Hash; return; case '*': mCurrToken.mTokenType = Token::Star; return; case 'h': // Have to deal with 'hh' if (*mCurrLoc == 'h') { mCurrLoc++; mCurrToken.mTokenType = Token::hh_Mod; return; } mCurrToken.mTokenType = Token::h_Mod; return; case 'l': // Have to deal with 'll' if (*mCurrLoc == 'l') { mCurrLoc++; mCurrToken.mTokenType = Token::ll_Mod; return; } mCurrToken.mTokenType = Token::l_Mod; return; case 'j': mCurrToken.mTokenType = Token::j_Mod; return; case 'z': mCurrToken.mTokenType = Token::z_Mod; return; case 't': mCurrToken.mTokenType = Token::t_Mod; return; case 'L': mCurrToken.mTokenType = Token::L_Mod; return; case 'c': mCurrToken.mTokenType = Token::c_Conv; mInSpec = false; // End of the format spec return; case 's': mCurrToken.mTokenType = Token::s_Conv; mInSpec = false; // End of the format spec return; case 'd': mCurrToken.mTokenType = Token::d_Conv; mInSpec = false; // End of the format spec return; case 'i': mCurrToken.mTokenType = Token::i_Conv; mInSpec = false; // End of the format spec return; case 'o': mCurrToken.mTokenType = Token::o_Conv; mInSpec = false; // End of the format spec return; case 'x': mCurrToken.mTokenType = Token::x_Conv; mInSpec = false; // End of the format spec return; case 'X': mCurrToken.mTokenType = Token::X_Conv; mInSpec = false; // End of the format spec return; case 'u': mCurrToken.mTokenType = Token::u_Conv; mInSpec = false; // End of the format spec return; case 'f': mCurrToken.mTokenType = Token::f_Conv; mInSpec = false; // End of the format spec return; case 'F': mCurrToken.mTokenType = Token::F_Conv; mInSpec = false; // End of the format spec return; case 'e': mCurrToken.mTokenType = Token::e_Conv; mInSpec = false; // End of the format spec return; case 'E': mCurrToken.mTokenType = Token::E_Conv; mInSpec = false; // End of the format spec return; case 'a': mCurrToken.mTokenType = Token::a_Conv; mInSpec = false; // End of the format spec return; case 'A': mCurrToken.mTokenType = Token::A_Conv; mInSpec = false; // End of the format spec return; case 'g': mCurrToken.mTokenType = Token::g_Conv; mInSpec = false; // End of the format spec return; case 'G': mCurrToken.mTokenType = Token::G_Conv; mInSpec = false; // End of the format spec return; case 'n': mCurrToken.mTokenType = Token::n_Conv; mInSpec = false; // End of the format spec return; case 'p': mCurrToken.mTokenType = Token::p_Conv; mInSpec = false; // End of the format spec return; case '0': if (*mCurrLoc < '1' || *mCurrLoc > '9') { // Next character not part of a larger integer mCurrToken.mTokenType = Token::Zero; return; } // Deliberately drop through case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': mCurrToken.mTokenString += currChar; while (*mCurrLoc >= '0' && *mCurrLoc <= '9') { mCurrToken.mTokenString += *mCurrLoc++; } // Create integer // Since we've created this integer string and we know it is simple we can use // atoi knowing that it won't throw an error mCurrToken.mTokenInt = atoi(mCurrToken.mTokenString.c_str()); mCurrToken.mTokenType = Token::Integer; return; } } } mCurrToken.mTokenType = Token::End; } bool PFParser::accept(PFParser::Token::TokenType s) { if (mCurrToken == s) { getToken(); return true; } return false; } bool PFParser::expect(Token::TokenType s) { if (accept(s)) return true; error(); return false; } int PFParser::format(void) { if (mCurrToken == Token::_None_) { getToken(); } while(mCurrToken != Token::End && mCurrToken != Token::Error) { if (accept(Token::String)) { } else if (accept(Token::Percent)) { return directive(); } } return 0; } int PFParser::directive(void) { int numArgs = 0; flags(); numArgs += width(); numArgs += precision(); length_modifier(); int numConvArgs = conversion(); if (numConvArgs == 0) { // Not expecting ANY arguments // Ignore any previous directives (width, precision etc.) numArgs = 0; } else { numArgs += numConvArgs; } return numArgs; } void PFParser::flags(void) { if (accept(Token::Minus)) { } if (accept(Token::Plus)) { } if (accept(Token::Space)) { } if (accept(Token::Zero)) { } if (accept(Token::Hash)) { } } int PFParser::width(void) { if (accept(Token::Integer)) { return 0; } else if (accept(Token::Star)) { return 1; } return 0; } int PFParser::precision(void) { if (accept(Token::Period)) { if (accept(Token::Integer)) { return 0; } else if (expect(Token::Star)) { return 1; } return 0; } return 0; } void PFParser::length_modifier(void) { if (accept(Token::hh_Mod)) { } else if (accept(Token::h_Mod)) { } else if (accept(Token::l_Mod)) { } else if (accept(Token::ll_Mod)) { } else if (accept(Token::j_Mod)) { mUnsupported = true; } else if (accept(Token::t_Mod)) { mUnsupported = true; } else if (accept(Token::z_Mod)) { mUnsupported = true; } else if (accept(Token::L_Mod)) { } } int PFParser::conversion(void) { int numArgs = 1; if (accept(Token::Percent)) { numArgs = 0; } else if (accept(Token::c_Conv)) { } else if (accept(Token::s_Conv)) { } else if (accept(Token::d_Conv)) { } else if (accept(Token::i_Conv)) { } else if (accept(Token::o_Conv)) { } else if (accept(Token::x_Conv)) { } else if (accept(Token::X_Conv)) { } else if (accept(Token::u_Conv)) { } else if (accept(Token::f_Conv)) { } else if (accept(Token::F_Conv)) { } else if (accept(Token::e_Conv)) { } else if (accept(Token::E_Conv)) { } else if (accept(Token::a_Conv)) { } else if (accept(Token::A_Conv)) { } else if (accept(Token::g_Conv)) { } else if (accept(Token::G_Conv)) { } else if (accept(Token::n_Conv)) { mUnsupported = true; } else if (expect(Token::p_Conv)) { } else { // Expect must have failed numArgs = 0; } return numArgs; } int CalcSizeFromHeader(unsigned char * memory) { PCM_PRINT_HEADER header = (PCM_PRINT_HEADER)memory; if((header->objectType == CM_PRINT_OBJECT_TYPE_MATRIX) || (header->objectType == CM_PRINT_OBJECT_TYPE_VECTOR)) { switch (header->dataType) { case CM_PRINT_DATA_TYPE_CHAR : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(char )); case CM_PRINT_DATA_TYPE_UCHAR : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned char )); case CM_PRINT_DATA_TYPE_INT : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(int )); case CM_PRINT_DATA_TYPE_UINT : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned int )); case CM_PRINT_DATA_TYPE_FLOAT : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(float )); case CM_PRINT_DATA_TYPE_SHORT : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(short )); case CM_PRINT_DATA_TYPE_USHORT : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned short )); case CM_PRINT_DATA_TYPE_QWORD : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(long long )); case CM_PRINT_DATA_TYPE_UQWORD : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(unsigned long long )); case CM_PRINT_DATA_TYPE_DOUBLE : return CM_PRINT_SIZE_WITH_PAYLOAD(header->height*header->width*sizeof(double )); default: CM_ASSERTMESSAGE("Error: Invalid print data type."); } return PRINT_HEADER_SIZE; } else if(header->objectType == CM_PRINT_OBJECT_TYPE_STRING || header->objectType == CM_PRINT_OBJECT_TYPE_FORMAT) { return PRINT_HEADER_SIZE + PRINT_FORMAT_STRING_SIZE; } else if(header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR) { if(!((header->dataType == CM_PRINT_DATA_TYPE_CHAR) || (header->dataType == CM_PRINT_DATA_TYPE_UCHAR) || (header->dataType == CM_PRINT_DATA_TYPE_UINT) || (header->dataType == CM_PRINT_DATA_TYPE_INT) || (header->dataType == CM_PRINT_DATA_TYPE_USHORT) || (header->dataType == CM_PRINT_DATA_TYPE_SHORT) || (header->dataType == CM_PRINT_DATA_TYPE_DOUBLE) || (header->dataType == CM_PRINT_DATA_TYPE_QWORD) || (header->dataType == CM_PRINT_DATA_TYPE_UQWORD) || (header->dataType == CM_PRINT_DATA_TYPE_FLOAT))) { CM_ASSERTMESSAGE("Error: Invalid print data type."); } return PRINT_HEADER_SIZE; } else { CM_ASSERTMESSAGE("Error: Invalid print object type."); return PRINT_HEADER_SIZE; } } void PFParser::flush(void) { if (mInputStart && mCurrLoc) { if (mCurrToken != Token::End && mCurrToken != Token::_None_) { // Tidy up any remaining characters // Any characters that remain to be flushed need to be check for illegal directives (e.g. %n // will cause an exception if attempted to be printed with no argument) int numArgs = format(); if (mUnsupported) { CM_PRINTF(mStreamOut,"Unsupported (but valid C++11) format string used : %s", mInputStart); reset(); } else if (mError) { CM_PRINTF(mStreamOut,"Error in printf format string : %s", mInputStart); reset(); } else if (numArgs > 0) { // Not enough arguments provided for remaining directives CM_PRINTF(mStreamOut,"Not enough (no) arguments supplied for format string : %s", mInputStart); reset(); } else { CM_PRINTF(mStreamOut,"%s", mInputStart); } } reset(); } } PRINT_FMT_STATUS PFParser::GetNextFmtToken(char* tkn, size_t size) { memset(tkn, 0, size); if (mNumMultArg) { if (!mArgsExpected) { // Copy the whole of the format string into the token if ((size_t)(mCurrLoc - mInputStart) <= size) { memcpy(tkn, mInputStart, mCurrLoc - mInputStart); tkn[mCurrLoc - mInputStart] = '\0'; return PF_SUCCESS; } return PF_FAIL; } // Still processing input arguments return PF_SUCCESS; } int numArgs = format(); switch (numArgs) { default: return PF_FAIL; // Something has gone wrong case 0: case 1: // Copy the whole of the format string into the token if ((size_t)(mCurrLoc - mInputStart) <= size) { memcpy(tkn, mInputStart, mCurrLoc - mInputStart); tkn[mCurrLoc - mInputStart] = '\0'; return PF_SUCCESS; } return PF_FAIL; case 2: case 3: mNumMultArg = numArgs - 1; mArgsExpected = numArgs - 1; return PF_SUCCESS; } } bool PFParser::outputToken(const char *tkn, PCM_PRINT_HEADER header) { if (mNumMultArg && mArgsExpected) { // Processing items for multi-arg directives if (header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR && header->dataType != CM_PRINT_DATA_TYPE_FLOAT && header->dataType != CM_PRINT_DATA_TYPE_DOUBLE && header->dataType != CM_PRINT_DATA_TYPE_QWORD && header->dataType != CM_PRINT_DATA_TYPE_UQWORD) { // Received an int type argument as expected switch (header->dataType) { case CM_PRINT_DATA_TYPE_INT : mArgs[mNumMultArg - mArgsExpected] = *((int* )&(header->scalar64)); break; case CM_PRINT_DATA_TYPE_UINT : mArgs[mNumMultArg - mArgsExpected] = *((unsigned int* )&(header->scalar64)); break; case CM_PRINT_DATA_TYPE_CHAR : mArgs[mNumMultArg - mArgsExpected] = *((char* )&(header->scalar64)); break; case CM_PRINT_DATA_TYPE_UCHAR : mArgs[mNumMultArg - mArgsExpected] = *((unsigned char* )&(header->scalar64)); break; case CM_PRINT_DATA_TYPE_SHORT : mArgs[mNumMultArg - mArgsExpected] = *((short* )&(header->scalar64)); break; case CM_PRINT_DATA_TYPE_USHORT : mArgs[mNumMultArg - mArgsExpected] = *((unsigned short*)&(header->scalar64)); break; } mArgsExpected -= 1; return true; } else { // Not received the expected argument // Dump what is in the format string and attempt to recover as well as possible return false; } } // Inform the user that they've used an unsupported format string if that is the case // (e.g. %jd, %td etc.) if (mUnsupported) { CM_PRINTF(mStreamOut,"Unsupported (but valid C++11) printf format string : %s", tkn); reset(); return true; } // Inform the user that they've got an error (illegal format string) if (mError) { CM_PRINTF(mStreamOut, "Error in printf format string : %s", tkn); reset(); return true; } // Output as appropriate if (!mNumMultArg) { switch (header->dataType) { case CM_PRINT_DATA_TYPE_INT : CM_PRINTF(mStreamOut, tkn, *((int*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UINT : CM_PRINTF(mStreamOut, tkn, *((unsigned int*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_CHAR : CM_PRINTF(mStreamOut, tkn, *((char*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UCHAR : CM_PRINTF(mStreamOut, tkn, *((unsigned char*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_FLOAT : CM_PRINTF(mStreamOut, tkn, *((float*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_SHORT : CM_PRINTF(mStreamOut, tkn, *((short*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_USHORT : CM_PRINTF(mStreamOut, tkn, *((unsigned short*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_DOUBLE : CM_PRINTF(mStreamOut, tkn, *((double*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_QWORD : CM_PRINTF(mStreamOut, tkn, *((long long*)&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UQWORD : CM_PRINTF(mStreamOut, tkn, *((unsigned long long*)&(header->scalar64))); break; } } else if (mNumMultArg == 1) { switch (header->dataType) { case CM_PRINT_DATA_TYPE_INT : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((int* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UINT : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((unsigned int* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_CHAR : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((char* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UCHAR : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((unsigned char* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_FLOAT : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((float* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_SHORT : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((short* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_USHORT : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((unsigned short* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_DOUBLE : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((double* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_QWORD : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((long long* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UQWORD : CM_PRINTF(mStreamOut,tkn, mArgs[0], *((unsigned long long* )&(header->scalar64))); break; } } else if (mNumMultArg == 2) { switch (header->dataType) { case CM_PRINT_DATA_TYPE_INT : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((int* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UINT : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((unsigned int* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_CHAR : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((char* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UCHAR : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((unsigned char* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_FLOAT : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((float* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_SHORT : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((short* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_USHORT : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((unsigned short* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_DOUBLE : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((double* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_QWORD : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((long long* )&(header->scalar64))); break; case CM_PRINT_DATA_TYPE_UQWORD : CM_PRINTF(mStreamOut,tkn, mArgs[0], mArgs[1], *((unsigned long long* )&(header->scalar64))); break; } } reset(); return true; } void PFParser::DumpMemory(unsigned char * memory) { PCM_PRINT_HEADER header = (PCM_PRINT_HEADER)memory; memory += PRINT_HEADER_SIZE; int threadid = header->tid; if(!mNumMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_MATRIX ) { CM_PRINTF(mStreamOut,"\n Thread id %d, Matrix , Width %ud, Height %ud \n", threadid, header->width, header->height); } else if(!mNumMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_VECTOR) { CM_PRINTF(mStreamOut, " \n Thread id %d, Vector , Width %ud\n", threadid, header->width); } else if(!mNumMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_FORMAT) { // Flush any remaining characters from existing format string (if any) flush(); setStart((char *)memory); } else if(!mNumMultArg && header->objectType == CM_PRINT_OBJECT_TYPE_STRING) { char tkn[PRINT_FORMAT_STRING_SIZE]; PRINT_FMT_STATUS status = GetNextFmtToken(tkn, PRINT_FORMAT_STRING_SIZE); if (status == PF_SUCCESS) { // Inform the user that they've used an unsupported format string if that is the case // (e.g. %jd, %td etc.) if (mUnsupported) { CM_PRINTF(mStreamOut, "Unsupported (but valid C++11) format string used : %s", tkn); } // Inform the user that they've got an error (illegal format string) if (mError) { CM_PRINTF(mStreamOut, "Error in printf format string : %s", tkn); } if (mUnsupported || mError) { reset(); return; } CM_PRINTF(mStreamOut, tkn, (char*)memory); reset(); } return; } else if(header->objectType == CM_PRINT_OBJECT_TYPE_SCALAR) { char tkn[PRINT_FORMAT_STRING_SIZE]; PRINT_FMT_STATUS status = GetNextFmtToken(tkn, PRINT_FORMAT_STRING_SIZE); if (status == PF_SUCCESS) { if (!outputToken(tkn, header)) { // Something has gone wrong // Reset multi-arg at least CM_PRINTF(mStreamOut, "Problem outputting with format string %s\n", tkn); mNumMultArg = mArgsExpected = 0; } } return; } else { if (mNumMultArg) { // Something has gone wrong in multi-arg so reset CM_PRINTF(mStreamOut, "Error in multi-arg directive\n"); mNumMultArg = 0; mArgsExpected = 0; } else { CM_PRINTF(mStreamOut, "Unknown TYPE\n"); } return; } } void DumpAllThreadOutput(FILE *streamout, unsigned char * dumpMem, size_t buffersize) { unsigned int off = PRINT_BUFFER_HEADER_SIZE; PFParser pState(streamout); while(1) { if((off + PRINT_HEADER_SIZE) >= buffersize) break; if(off >= (*(unsigned int *)dumpMem)) break; unsigned int offsetFromHeader = CalcSizeFromHeader(dumpMem + off); if( (off + offsetFromHeader) >= buffersize ) break; pState.DumpMemory(dumpMem + off); off += offsetFromHeader; } // Flush any remaining characters in the format buffer pState.flush(); } #endif