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__();
}
