Esempio n. 1
0
static void
do_harg_dump
  (harglst *a,
   int  level)
{
  hargwalk *w ;
  harg **R, *r ;
  static void **harg_walk_next_ptr (hargwalk*);

  if(a == 0 || (w = harg_walk_init (a)) == 0) {
    do_printf ("-error; no such list!\n",0,0,0,0,0);
    return;
  } 

  while ((R = (harg**)harg_walk_next_ptr (w)) != 0) {
    int ptrky, flags = 0;
    do_indent (level);
    if ((r = *R) == 0) {
      do_printf ("Warning: NULL entry in list\n",0,0,0,0,0);
      continue ;
    }
    ptrky = (is_ptrkey_type (r->type) != 0);
    switch (get_simple_type (r->type)) {
    case HARG_STRING:
      do_printf ("\"%s\"",  R, (void*)r->d.d.data, flags, ptrky, 0);
      continue ;
    case HARG_BLOB:
      do_printf ("%#x[%u]", R, (void*)r->d.d.data, flags, ptrky, r->size);
      continue ;
#ifdef ARG_ARGLIST
    case HARG_ARGLIST:
      do_newlevel ();
      do_printf ("(old mode>) sublist ...", R, 0, flags, ptrky, 0);
      arg_dump (r->d.d.ptr [0], level+1);
      continue ;
#endif
    case HARG_HARG:
      /* do_newlevel (); */
      if (is_remote_type (r->type))
	do_printf ("remote sublist{%s} ...", R, r->d.d.ptr+1, flags, ptrky, 0);
      else
	do_printf ("sublist{%#x} ...", R, r->d.d.ptr [0], flags, ptrky, 0);
      do_harg_dump (r->d.d.ptr [0], level+1);
      continue ;
    case HARG_INT:
      do_printf ("%d",  R, r->d.d.ptr [0], flags, ptrky, 0);
      continue;
    default:
      do_printf ("*%#x", R, r->d.d.ptr [0], flags, ptrky, 0);
    }
  }
  harg_walk_stop (w);
}
Esempio n. 2
0
int kprintf( int loglevel, const char* format, ... ) {
    va_list args;

   // spinlock_disable( &console_lock );

    /* Print the text */

    va_start( args, format );
    do_printf( kprintf_helper, ( void* )&loglevel, format, args );
    va_end( args );

    /* Flush the consoles */

    if ( ( loglevel > DEBUG ) &&
         ( screen != NULL ) &&
         ( screen->ops->flush != NULL ) ) {
        screen->ops->flush( screen );
    }

    if ( ( debug != NULL ) &&
         ( debug->ops->flush != NULL ) ) {
        debug->ops->flush( debug );
    }

   // spinunlock_enable( &console_lock );

    return 0;
}
Esempio n. 3
0
File: conf.c Progetto: rvs/libtc
static int
tcc_writesection(conf_section *ts, void *file, int lv, char *d, tcio_fn ofn)
{
    int l = lv * 8;
    tclist_item_t *li = NULL;
    char *m;

    do_printf(file, ofn, "%*s%s", l, "", ts->name);

    while((m = tclist_next(ts->merge, &li)))
	fprintf(file, " : %s", m);
    do_printf(file, ofn, " %c\n", d[0]);
    tcc_writelist(ts->entries, file, lv + 1, ofn);
    do_printf(file, ofn, "%*s%c\n", l, "", d[1]);
    return 0;
}
Esempio n. 4
0
CELL *
bi_printf(CELL *sp)
{
    register int k;
    register CELL *p;
    FILE *fp;

    TRACE_FUNC("bi_printf", sp);

    k = sp->type;
    if (k < 0) {
    /* k has redirection */
    if ((--sp)->type < C_STRING)
        cast1_to_s(sp);
    fp = (FILE *) file_find(string(sp), k);
    free_STRING(string(sp));
    k = (--sp)->type;
    /* k is now number of args including format */
    } else
    fp = stdout;

    sp -= k;            /* sp points at the format string */
    k--;

    if (sp->type < C_STRING)
    cast1_to_s(sp);
    do_printf(fp, string(sp)->str, (unsigned) k, sp + 1);
    free_STRING(string(sp));

    /* cleanup arguments on eval stack */
    for (p = sp + 1; k; k--, p++)
    cell_destroy(p);
    return --sp;
}
Esempio n. 5
0
int vsprintf(char *buffer, const char *fmt, va_list args)
{
    int ret_val = do_printf(fmt, args, vsprintf_help, (void *)buffer);
    buffer[ret_val] = '\0';

    return ret_val;
}
Esempio n. 6
0
// =====================================================================================================================
void kprintf_unlocked(const char* format, ...)
{
    va_list args;

    va_start(args, format);
    do_printf(kprintf_helper, NULL, format, args);
    va_end(args);
}
Esempio n. 7
0
// =====================================================================================================================
void dprintf(const char* format, ...)
{
    va_list args;

    va_start(args, format);
    do_printf(dprintf_helper, NULL, format, args);
    va_end(args);
}
Esempio n. 8
0
int vsprintf(char *buf, const char *fmt, va_list args)
{
	int rv;

	rv = do_printf(fmt, args, vsprintf_help, (void *)buf);
	buf[rv] = '\0';
	return rv;
}
Esempio n. 9
0
Response & Response::status(int code)
{
    if( statusSet ) return *this;

    do_printf("HTTP/1.1 %d OK\r\n",code);
    statusSet = true;
    return *this;
}
Esempio n. 10
0
// Função printf
void printf(const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);
	(void)do_printf(fmt, args, kprintf_help, NULL, 0);
	va_end(args);
}
Esempio n. 11
0
WORD CDECL sprintf(BYTE * buff, CONST BYTE * fmt, ...)
{
  WORD ret;

  charp = buff;
  ret = do_printf(fmt, (BYTE **) & fmt + 1);
  handle_char(NULL);
  return ret;
}
Esempio n. 12
0
void printf(const char *fmt, ...)
{
	va_list args;

	va_start(args, fmt);

	do_printf(fmt, args, printf_helper, NULL);

	va_end(args);
}
Esempio n. 13
0
void printfln(char* fmt, ...)
{
	va_list args;

	va_start(args, fmt);

	do_printf(fmt, args, printf_helper, NULL);

	putc('\n');

	va_end(args);
}
Esempio n. 14
0
// =====================================================================================================================
void kprintf(const char* format, ...)
{
    va_list args;

    spinlock_disable(&s_console_lock);

    va_start(args, format);
    do_printf(kprintf_helper, NULL, format, args);
    va_end(args);

    spinunlock_enable(&s_console_lock);
}
Esempio n. 15
0
Response & Response::contentType(char const * type)
{
    if( contentTypeSet ) return *this;

    if( ! statusSet )
    {
        status(200);
    }

    do_printf("Content-Type: %s\r\n",type);
    contentTypeSet = true;
    return *this;
}
Esempio n. 16
0
/********************************************************************
 * Prints the string to the con_idx's console buffer. Takes care of
 * updating the screen when it's the current console.
 *
 * In  : con_idx = index number of the console.
 *       fmt     = string which holds a normal "printf" format
 *       ...     = unknown number of parameters of all kinds (va_list)
 *
 * Out : -1 on error, 1 on OK
 */
int con_printf (console_t *console, const char *fmt, ...) {
  va_list args;

  if (console == NULL) return ERR_CON_INVALID_CONSOLE;

  va_start (args, fmt);
  do_printf (fmt, args, &con_printf_helper, (void *)console);
  va_end (args);

  // Show the string we just printed if necessary...
  con_flush (console);

  // Return
  return ERR_OK;
}
Esempio n. 17
0
File: conf.c Progetto: rvs/libtc
static int
tcc_writeentry(tcc_entry *te, void *file, int lv, tcio_fn ofn)
{
    tclist_item_t *li = NULL;
    tcc_value *tv;
    int l = lv * 8;

    switch(te->type){
    case TCC_VALUE:
	do_printf(file, ofn, "%*s%s", l, "", te->value.key);
	while((tv = tclist_next(te->value.values, &li)) != NULL){
	    char sd;
	    switch(tv->type & TCC_TYPEMASK){
	    case TCC_INTEGER:
		do_printf(file, ofn, " %ld", tv->value.integer);
		break;
	    case TCC_FLOAT:
		do_printf(file, ofn, " %.16g", tv->value.floating);
		break;
	    case TCC_BOOLEAN:
		do_printf(file, ofn, " %s",
			  tv->value.boolean? "true": "false");
		break;
	    case TCC_STRING:
		sd = tv->type & TCC_EXPAND? '"': '\'';
		do_printf(file, ofn, " %c%s%c", sd, tv->value.string, sd);
		break;
	    case TCC_REF:
		do_printf(file, ofn, " %s", tv->value.string);
		break;
	    }
	}
	do_printf(file, ofn, "\n");
	break;

    case TCC_SECTION:
	tcc_writesection(te->section, file, lv, "{}", ofn);
	break;

    case TCC_MSECTION:
	tcc_writesection(te->section, file, lv, "[]", ofn);
	break;

    default:
	fprintf(stderr, "Internal error.\n");
	return -1;
    }

    return 0;
}
Esempio n. 18
0
int dprintf_unlocked( const char* format, ... ) {
#ifndef MK_RELEASE_BUILD
    va_list args;

    /* Print the text */

    va_start( args, format );
    do_printf( dprintf_helper, NULL, format, args );
    va_end( args );

    /* Flush the debug console */

    if ( ( debug != NULL ) && ( debug->ops->flush != NULL ) ) {
        debug->ops->flush( debug );
    }
#endif /* !MK_RELEASE_BUILD */

    return 0;
}
Esempio n. 19
0
void panic(const char *fmt, ...)
{
	set_con(get_con());
	va_list args;
	va_start(args, fmt);

	disable();
	set_color(CRED, CBLACK);
	puts("\nPANIC: ");

	set_color(CBRIGHTWHITE, CBLACK);

	(void)do_printf(fmt, args, kprintf_help, NULL);

	va_end(args);

	while(1){
		asm("cli\n"
            "hlt\n");
	}
}
Esempio n. 20
0
int kvprintf( int loglevel, const char* format, va_list args ) {
   // spinlock_disable( &console_lock );

    /* Print the text */

    do_printf( kprintf_helper, ( void* )&loglevel, format, args );

    /* Flush the consoles */

    if ( ( screen != NULL ) && ( screen->ops->flush != NULL ) ) {
        screen->ops->flush( screen );
    }

    if ( ( debug != NULL ) && ( debug->ops->flush != NULL ) ) {
        debug->ops->flush( debug );
    }

  //  spinunlock_enable( &console_lock );

    return 0;
}
Esempio n. 21
0
CELL *
bi_sprintf(CELL *sp)
{
    CELL *p;
    int argcnt = sp->type;
    STRING *sval;

    TRACE_FUNC("bi_sprintf", sp);

    sp -= argcnt;        /* sp points at the format string */
    argcnt--;

    if (sp->type != C_STRING)
    cast1_to_s(sp);
    sval = do_printf((FILE *) 0, string(sp)->str, (unsigned) argcnt, sp + 1);
    free_STRING(string(sp));
    sp->ptr = (PTR) sval;

    /* cleanup */
    for (p = sp + 1; argcnt; argcnt--, p++)
    cell_destroy(p);

    return sp;
}
Esempio n. 22
0
int vprintf(const char *fmt, va_list args)
{
    return do_printf(fmt, args, vprintf_help, (void *)0);
}
Esempio n. 23
0
int vprintf(const char *fmt, va_list args)
{
	return do_printf(fmt, args, vprintf_help, NULL);
}
Esempio n. 24
0
/* printf -- short version of printf to conserve space */
WORD CDECL printf(CONST BYTE * fmt, ...)
{
  charp = 0;
  return do_printf(fmt, (BYTE **) & fmt + 1);
}
Esempio n. 25
0
// =====================================================================================================================
void kvprintf_unlocked(const char* format, va_list args)
{
    do_printf(kprintf_helper, NULL, format, args);
}
Esempio n. 26
0
/*
ULONG FAR retcs(int i)
{
    char *p = (char*)&i;
    
    p -= 4;
    return *(ULONG *)p;
}
*/
COUNT do_printf(CONST BYTE * fmt, BYTE ** arg)
{
  int base;
  BYTE s[11], FAR * p;
  int c, flag, size, fill;
  int longarg;
  long currentArg;

/*  
  long cs = retcs(1);
  put_console("0123456789ABCDEF"[(cs >> 28) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >> 24) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >> 20) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >> 16) & 0x0f]);
  put_console(':');
  put_console("0123456789ABCDEF"[(cs >> 12) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >>  8) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >>  4) & 0x0f]);
  put_console("0123456789ABCDEF"[(cs >>  0) & 0x0f]);
*/
  while ((c = *fmt++) != '\0')
  {
    if (c != '%')
    {
      handle_char(c);
      continue;
    }

    longarg = FALSE;
    size = 0;
    flag = RIGHT;
    fill = ' ';

    if (*fmt == '-')
    {
      flag = LEFT;
      fmt++;
    }

    if (*fmt == '0')
    {
      fill = '0';
      fmt++;
    }

    while (*fmt >= '0' && *fmt <= '9')
    {
      size = size * 10 + (*fmt++ - '0');
    }

    if (*fmt == 'l')
    {
      longarg = TRUE;
      fmt++;
    }

    c = *fmt++;
    switch (c)
    {
      case '\0':
        return 0;

      case 'c':
        handle_char(*(COUNT *) arg++);
        continue;

      case 'p':
        {
          UWORD w[2];
          w[1] = *((UWORD *) arg);
          arg += sizeof(UWORD) / sizeof(BYTE *);
          w[0] = *((UWORD *) arg);
          arg += sizeof(UWORD) / sizeof(BYTE *);
          do_printf("%04x:%04x", (BYTE **) & w);
          continue;
        }

      case 's':
        p = *arg++;
        goto do_outputstring;

      case 'F':
        fmt++;
        /* we assume %Fs here */
      case 'S':
        p = *((BYTE FAR **) arg);
        arg += sizeof(BYTE FAR *) / sizeof(BYTE *);
        goto do_outputstring;

      case 'i':
      case 'd':
        base = -10;
        goto lprt;

      case 'o':
        base = 8;
        goto lprt;

      case 'u':
        base = 10;
        goto lprt;

      case 'X':
      case 'x':
        base = 16;

      lprt:
        if (longarg)
        {
          currentArg = *((LONG *) arg);
          arg += sizeof(LONG) / sizeof(BYTE *);
        }
        else
        {
          if (base < 0)
          {
            currentArg = *((int *)arg);
            arg += sizeof(int) / sizeof(BYTE *);
          }
          else
          {
            currentArg = *((unsigned int *)arg);
            arg += sizeof(unsigned int) / sizeof(BYTE *);
          }
        }

        ltob(currentArg, s, base);

        p = s;
      do_outputstring:

        size -= fstrlen(p);

        if (flag == RIGHT)
        {
          for (; size > 0; size--)
            handle_char(fill);
        }
        for (; *p != '\0'; p++)
          handle_char(*p);

        for (; size > 0; size--)
          handle_char(fill);

        continue;

      default:
        handle_char('?');

        handle_char(c);
        break;

    }
  }
  return 0;
}
Esempio n. 27
0
void goto_convertt::do_function_call_symbol(
  const exprt &lhs,
  const symbol_exprt &function,
  const exprt::operandst &arguments,
  goto_programt &dest)
{
  if(function.get_bool("#invalid_object"))
    return; // ignore

  // lookup symbol
  const irep_idt &identifier=function.get_identifier();

  const symbolt *symbol;
  if(ns.lookup(identifier, symbol))
  {
    err_location(function);
    throw "error: function `"+id2string(identifier)+"' not found";
  }

  if(symbol->type.id()!=ID_code)
  {
    err_location(function);
    throw "error: function `"+id2string(identifier)+"' type mismatch: expected code";
  }
  
  if(identifier==CPROVER_PREFIX "assume" ||
     identifier=="__VERIFIER_assume")
  {
    if(arguments.size()!=1)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have one argument";
    }

    goto_programt::targett t=dest.add_instruction(ASSUME);
    t->guard=arguments.front();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    
    // let's double-check the type of the argument
    if(t->guard.type().id()!=ID_bool)
      t->guard.make_typecast(bool_typet());

    if(lhs.is_not_nil())
    {
      err_location(function);
      throw id2string(identifier)+" expected not to have LHS";
    }
  }
  else if(identifier=="__VERIFIER_error")
  {
    if(!arguments.empty())
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have no arguments";
    }

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=false_exprt();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);

    if(lhs.is_not_nil())
    {
      err_location(function);
      throw id2string(identifier)+" expected not to have LHS";
    }
  }
  else if(has_prefix(id2string(identifier), "java::java.lang.AssertionError.<init>:"))
  {
    // insert function call anyway
    code_function_callt function_call;
    function_call.lhs()=lhs;
    function_call.function()=function;
    function_call.arguments()=arguments;
    function_call.add_source_location()=function.source_location();

    copy(function_call, FUNCTION_CALL, dest);

    if(arguments.size()!=1 && arguments.size()!=2)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have one or two arguments";
    }

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=false_exprt();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);    
    t->source_location.set_comment("assertion at "+function.source_location().as_string());
  }
  else if(identifier=="assert" &&
          !ns.lookup(identifier).location.get_function().empty())
  {
    if(arguments.size()!=1)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have one argument";
    }

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=arguments.front();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);
    t->source_location.set_comment("assertion "+id2string(from_expr(ns, "", t->guard)));
    
    // let's double-check the type of the argument
    if(t->guard.type().id()!=ID_bool)
      t->guard.make_typecast(bool_typet());

    if(lhs.is_not_nil())
    {
      err_location(function);
      throw id2string(identifier)+" expected not to have LHS";
    }
  }
  else if(identifier==CPROVER_PREFIX "assert")
  {
    if(arguments.size()!=2)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have two arguments";
    }
    
    const irep_idt description=
      get_string_constant(arguments[1]);

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=arguments[0];
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);
    t->source_location.set_comment(description);
    
    // let's double-check the type of the argument
    if(t->guard.type().id()!=ID_bool)
      t->guard.make_typecast(bool_typet());

    if(lhs.is_not_nil())
    {
      err_location(function);
      throw id2string(identifier)+" expected not to have LHS";
    }
  }
  else if(identifier==CPROVER_PREFIX "printf")
  {
    do_printf(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "scanf")
  {
    do_scanf(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "input" ||
          identifier=="__CPROVER::input")
  {
    do_input(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "output" ||
          identifier=="__CPROVER::output")
  {
    do_output(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "atomic_begin" ||
          identifier=="__CPROVER::atomic_begin" ||
          identifier=="__VERIFIER_atomic_begin")
  {
    do_atomic_begin(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "atomic_end" ||
          identifier=="__CPROVER::atomic_end" ||
          identifier=="__VERIFIER_atomic_end")
  {
    do_atomic_end(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "prob_biased_coin")
  {
    do_prob_coin(lhs, function, arguments, dest);
  }
  else if(has_prefix(id2string(identifier), CPROVER_PREFIX "prob_uniform_"))
  {
    do_prob_uniform(lhs, function, arguments, dest);
  }
  else if(has_prefix(id2string(identifier), "nondet_") ||
          has_prefix(id2string(identifier), "__VERIFIER_nondet_"))
  {
    // make it a side effect if there is an LHS
    if(lhs.is_nil()) return;
    
    exprt rhs;
    
    // We need to special-case for _Bool, which
    // can only be 0 or 1.
    if(lhs.type().id()==ID_c_bool)
    {
      rhs=side_effect_expr_nondett(bool_typet());
      rhs.add_source_location()=function.source_location();
      rhs.set(ID_C_identifier, identifier);
      rhs=typecast_exprt(rhs, lhs.type());
    } 
    else
    {
      rhs=side_effect_expr_nondett(lhs.type());
      rhs.add_source_location()=function.source_location();
      rhs.set(ID_C_identifier, identifier);
    }

    code_assignt assignment(lhs, rhs);
    assignment.add_source_location()=function.source_location();
    copy(assignment, ASSIGN, dest);
  }
  else if(has_prefix(id2string(identifier), CPROVER_PREFIX "uninterpreted_"))
  {
    // make it a side effect if there is an LHS
    if(lhs.is_nil()) return;

    function_application_exprt rhs;
    rhs.type()=lhs.type();
    rhs.add_source_location()=function.source_location();
    rhs.function()=function;
    rhs.arguments()=arguments;

    code_assignt assignment(lhs, rhs);
    assignment.add_source_location()=function.source_location();
    copy(assignment, ASSIGN, dest);
  }
  else if(has_prefix(id2string(identifier), CPROVER_PREFIX "array_set"))
  {
    do_array_set(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "array_equal" ||
          identifier=="__CPROVER::array_equal")
  {
    do_array_equal(lhs, function, arguments, dest);
  }
  else if(identifier==CPROVER_PREFIX "array_copy" ||
          identifier=="__CPROVER::array_equal")
  {
    do_array_copy(lhs, function, arguments, dest);
  }
  else if(identifier=="printf")
  /*
          identifier=="fprintf" ||
          identifier=="sprintf" ||
          identifier=="snprintf")
  */
  {
    do_printf(lhs, function, arguments, dest);
  }
  else if(identifier=="__assert_fail" ||
          identifier=="_assert" ||
          identifier=="__assert_c99" ||
          identifier=="_wassert")
  {
    // __assert_fail is Linux
    // These take four arguments:
    // "expression", "file.c", line, __func__
    // klibc has __assert_fail with 3 arguments
    // "expression", "file.c", line

    // MingW has
    // void _assert (const char*, const char*, int);
    // with three arguments:
    // "expression", "file.c", line

    // This has been seen in Solaris 11.
    // Signature:
    // void __assert_c99(const char *desc, const char *file, int line, const char *func);

    // _wassert is Windows. The arguments are
    // L"expression", L"file.c", line

    if(arguments.size()!=4 &&
       arguments.size()!=3)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have four arguments";
    }
    
    const irep_idt description=
      "assertion "+id2string(get_string_constant(arguments[0]));

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=false_exprt();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);
    t->source_location.set_comment(description);
    // we ignore any LHS
  }
  else if(identifier=="__assert_rtn" ||
          identifier=="__assert")
  {
    // __assert_rtn has been seen on MacOS;
    // __assert is FreeBSD and Solaris 11.
    // These take four arguments:
    // __func__, "file.c", line, "expression"
    // On Solaris 11, it's three arguments:
    // "expression", "file", line
    
    irep_idt description;
    
    if(arguments.size()==4)
    {
      description=
        "assertion "+id2string(get_string_constant(arguments[3]));
    }
    else if(arguments.size()==3)
    {
      description=
        "assertion "+id2string(get_string_constant(arguments[1]));
    }
    else
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have four arguments";
    }

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=false_exprt();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);
    t->source_location.set_comment(description);
    // we ignore any LHS
  }
  else if(identifier=="__assert_func")
  {
    // __assert_func is newlib (used by, e.g., cygwin)
    // These take four arguments:
    // "file.c", line, __func__, "expression"
    if(arguments.size()!=4)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have four arguments";
    }

    const irep_idt description=
      "assertion "+id2string(get_string_constant(arguments[3]));

    goto_programt::targett t=dest.add_instruction(ASSERT);
    t->guard=false_exprt();
    t->source_location=function.source_location();
    t->source_location.set("user-provided", true);
    t->source_location.set_property_class(ID_assertion);
    t->source_location.set_comment(description);
    // we ignore any LHS
  }
  else if(identifier==CPROVER_PREFIX "fence")
  {
    if(arguments.size()<1)
    {
      err_location(function);
      throw "`"+id2string(identifier)+"' expected to have at least one argument";
    }

    goto_programt::targett t=dest.add_instruction(OTHER);
    t->source_location=function.source_location();
    t->code.set(ID_statement, ID_fence);

    forall_expr(it, arguments)
    {
      const irep_idt kind=get_string_constant(*it);
      t->code.set(kind, true);
    }
  }
  else if(identifier=="__builtin_prefetch")