int pcre_exec(const pcre *argument_re, const pcre_extra *extra_data, PCRE_SPTR subject, int length, int start_offset, int options, int *offsets, int offsetcount) { __coverity_panic__(); }
void osl_assert(char *exp, char *file, int line) { char tempbuf[256]; char *basename; basename = strrchr(file, '/'); /* skip the '/' */ if (basename) basename++; if (!basename) basename = file; #ifdef BCMASSERT_LOG snprintf(tempbuf, 64, "\"%s\": file \"%s\", line %d\n", exp, basename, line); bcm_assert_log(tempbuf); #endif /* BCMASSERT_LOG */ #ifdef __COVERITY__ /* Inform Coverity that execution will not continue past this point */ __coverity_panic__(); #endif }
void *isc__mem_allocate(void *mem, unsigned int size FLARG) { if (!mem) __coverity_panic__(); __coverity_negative_sink__(size); if (condition) return (0); return (__coverity_alloc__(size)); }
void g_assertion_message_expr(const char *domain, const char *file, int line, const char *func, const char *expr) { __coverity_panic__(); }
void * isc__mem_reallocate(void *mem, void *ptr, size_t size FLARG) { char *p = (char *)0; size_t l; if (!mem) __coverity_panic__(); if (size > 0) { p = isc__mem_allocate(mem, size FLARG_PASS); if (p && ptr) { l = (l > size) ? size : l; memcpy(p, ptr, l); __coverity_free__(ptr); } } else if (ptr) __coverity_free__(ptr); return (p); }
void FEwrong_type_nth_arg(cl_object function, cl_narg narg, cl_object value, cl_object type) { __coverity_panic__(); }
// // exit() ends execution // void exit(int status) { __coverity_panic__(); }
// When tag is 1 or 2, let coverity know that execution is halting. Those // tags correspond to INT_FATAL and USR_FATAL respectively. // // INT_FATAL, et al, work by calling setupError and then // handleError. setupError simply sets some static globals, then handleError // looks at those to decide how to error. For example, when INT_FATAL calls // handleError it will abort execution because exit_immediately is true. // // Here we're fibbing to coverity by telling it that setupError results in // abort (as opposed to handleError), but the effect should be the same. void setupError(const char *filename, int lineno, int tag) { if (tag == 1 || tag == 2) { __coverity_panic__(); } }
void Py_FatalError(const char *msg) { __coverity_panic__(); }
void __attribute__((noreturn)) _abort(void) { __coverity_panic__(); }
// Tell coverity that this function always exits void doAppErr(char const * expr, char const * file, long line) { __coverity_panic__(); }
void WinAssert(char * text, char *filename, int line) { __coverity_panic__(); }
void special_abort(const char* msg) { __coverity_panic__(); }
void isc__mem_putanddetach(void *mem, void *ptr, unsigned int size FLARG) { if (!mem) __coverity_panic__(); __coverity_free__(ptr); }
void throw3 (const char *, const char *, int) { __coverity_panic__(); }
void _throw5 (const char *fname, int line, int numarg, const T & a1, const U & a2, const V & a3, const W & a4, const X & a5) { __coverity_panic__(); }
// Tell coverity that this function exits when value is false void doAssertWithCallstack(bool value) { if (!value) { __coverity_panic__(); } }
void lyx_exit(int exit_code) { __coverity_panic__(); }
void WinAssert(char * text, char *filename, int line, const char * format, ... ) { __coverity_panic__(); }
// Indicate that our abort function really is that ... static void ink_die_die_die() { __coverity_panic__(); }
std::shared_ptr<FileDescriptor> add(int fileDescriptor) { __coverity_panic__(); }
// Teach Coverity that this aborts in all compilation modes. void _TSReleaseAssert(const char* txt, const char* f, int l) { __coverity_panic__(); }
void V3Error::v3errorEnd (ostringstream& sstr) { #if defined(__COVERITY__) || defined(__cppcheck__) if (s_errorCode==V3ErrorCode::EC_FATAL) __coverity_panic__(x); #endif // Skip suppressed messages if (s_errorSuppressed // On debug, show only non default-off warning to prevent pages of warnings && (!debug() || s_errorCode.defaultsOff())) return; string msg = msgPrefix()+sstr.str(); if (msg[msg.length()-1] != '\n') msg += '\n'; // Suppress duplicates if (s_messages.find(msg) != s_messages.end()) return; s_messages.insert(msg); // Output cerr<<msg; if (!s_errorSuppressed && s_errorCode!=V3ErrorCode::EC_INFO) { if (!s_describedEachWarn[s_errorCode] && !s_pretendError[s_errorCode]) { s_describedEachWarn[s_errorCode] = true; if (s_errorCode>=V3ErrorCode::EC_FIRST_WARN && !s_describedWarnings) { cerr<<msgPrefix()<<"Use \"/* verilator lint_off "<<s_errorCode.ascii() <<" */\" and lint_on around source to disable this message."<<endl; s_describedWarnings = true; } if (s_errorCode.dangerous()) { cerr<<msgPrefix()<<"*** See the manual before disabling this,"<<endl; cerr<<msgPrefix()<<"else you may end up with different sim results."<<endl; } } // If first warning is not the user's fault (internal/unsupported) then give the website // Not later warnings, as a internal may be caused by an earlier problem if (s_tellManual == 0) { if (s_errorCode.mentionManual() || sstr.str().find("Unsupported") != string::npos) { s_tellManual = 1; } else { s_tellManual = 2; } } if (isError(s_errorCode, s_errorSuppressed)) incErrors(); else incWarnings(); if (s_errorCode==V3ErrorCode::EC_FATAL || s_errorCode==V3ErrorCode::EC_FATALSRC) { static bool inFatal = false; if (!inFatal) { inFatal = true; if (s_tellManual==1) { cerr<<msgPrefix()<<"See the manual and http://www.veripool.org/verilator for more assistance."<<endl; s_tellManual = 2; } #ifndef _V3ERROR_NO_GLOBAL_ if (debug()) { v3Global.rootp()->dumpTreeFile(v3Global.debugFilename("final.tree",990)); if (s_errorExitCb) s_errorExitCb(); V3Stats::statsFinalAll(v3Global.rootp()); V3Stats::statsReport(); } #endif } vlAbort(); } else if (isError(s_errorCode, s_errorSuppressed)) { // We don't dump tree on any error because a Visitor may be in middle of // a tree cleanup and cause a false broken problem. if (s_errorExitCb) s_errorExitCb(); } } }
int luaL_error (void *L, const char *fmt, ...) { __coverity_panic__(); }