home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / sim / z8k / support.c < prev    next >
C/C++ Source or Header  |  1995-09-08  |  15KB  |  784 lines
  1. /* support routines for interpreted instructions
  2.    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
  3.  
  4. This file is part of Z8KSIM
  5.  
  6. Z8KSIM is free software; you can redistribute it and/or modify
  7. it under the terms of the GNU General Public License as published by
  8. the Free Software Foundation; either version 2, or (at your option)
  9. any later version.
  10.  
  11. Z8KSIM is distributed in the hope that it will be useful,
  12. but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. GNU General Public License for more details.
  15.  
  16. You should have received a copy of the GNU General Public License
  17. along with Z8KZIM; if not, write to the Free Software
  18. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19.  
  20. #include "config.h"
  21.  
  22. #include <ansidecl.h>
  23. #include <signal.h>
  24.  
  25. #include "tm.h"
  26. #include "sim.h"
  27. #include "mem.h"
  28. #include <stdio.h>
  29. #ifdef HAVE_TIME_H
  30. #include <time.h>
  31. #endif
  32. #ifdef HAVE_SYS_TIMES_H
  33. #include <sys/times.h>
  34. #endif
  35. #include <sys/types.h>
  36. #include <sys/stat.h>
  37. #include <sys/param.h>
  38. #include "remote-sim.h"
  39. #include "syscall.h"
  40.  
  41. static int get_now PARAMS ((void));
  42. static int now_persec PARAMS ((void));
  43. static int put_long PARAMS ((sim_state_type * context, int ptr, int value));
  44. static int put_short PARAMS ((sim_state_type * context, int ptr, int value));
  45.  
  46. int sim_z8001_mode;
  47.  
  48. static int
  49. get_now ()
  50. {
  51. #ifdef HAVE_SYS_TIMES_H
  52.   struct tms b;
  53.  
  54.   times (&b);
  55.   return b.tms_utime + b.tms_stime;
  56. #else
  57.   return time (0);
  58. #endif
  59. }
  60.  
  61. static int
  62. now_persec ()
  63. {
  64.   return 50;
  65. }
  66.  
  67.  
  68. /* #define LOG /* define this to print instruction use counts */
  69.  
  70. #ifdef __GNUC__
  71. #define INLINE __inline__
  72. #include "inlines.h"
  73. #else
  74. #include "inlines.h"
  75. #endif
  76.  
  77. /* This holds the entire cpu context */
  78. static sim_state_type the_state;
  79.  
  80. int
  81. fail (context, dummy)
  82.      sim_state_type *context;
  83.      int dummy;
  84. {
  85.   context->exception = SIM_BAD_INST;
  86.   return 1;
  87. }
  88.  
  89. void
  90. sfop_bad1 (context)
  91.      sim_state_type *context;
  92. {
  93.   context->exception
  94.     = SIM_BAD_INST;
  95. }
  96.  
  97. void
  98. bfop_bad1 (context)
  99.      sim_state_type *context;
  100. {
  101.   context->exception
  102.     = SIM_BAD_INST;
  103. }
  104.  
  105. void
  106. fop_bad (context)
  107.      sim_state_type *context;
  108. {
  109.   context->exception =
  110.     SIM_BAD_INST;
  111. }
  112.  
  113. /* Table of bit counts for all byte values */
  114.  
  115. char the_parity[256] =
  116. {
  117.   0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3,
  118.   4, 2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4,
  119.   4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3, 2,
  120.   3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5,
  121.   4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4,
  122.   5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3,
  123.   3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 2,
  124.   3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6,
  125.   4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5,
  126.   6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 3, 4, 4, 5, 4, 5,
  127.   5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6,
  128.   7, 7, 8};
  129.  
  130.  
  131. int read ();
  132. int write ();
  133. int open ();
  134. int close ();
  135. int open ();
  136. int close ();
  137.  
  138. int link ();
  139. int fstat ();
  140.  
  141. static int
  142. put_short (context, ptr, value)
  143.      sim_state_type *context;
  144.      int ptr;
  145.      int value;
  146. {
  147.   put_word_mem_da (context, ptr, value);
  148.   return ptr + 2;
  149. }
  150.  
  151. static int
  152. put_long (context, ptr, value)
  153.      sim_state_type *context;
  154.      int
  155.        ptr;
  156.      int value;
  157. {
  158.   put_long_mem_da (context, ptr, value);
  159.   return ptr + 4;
  160. }
  161.  
  162. #define aptr(x) ((sitoptr(x)) + (char *)(context->memory))
  163.  
  164. static int args[3];
  165. static int arg_index;        /* Translate a z8k system call into a host system call */
  166. void
  167. support_call (context, sc)
  168.      sim_state_type *context;
  169.      int sc;
  170. {
  171.   extern int errno;
  172.   int ret;
  173.   int retnext = 0;
  174.   int fd;
  175.  
  176.   int olderrno = errno;
  177.   errno = 0;
  178.   switch (sc)
  179.     {
  180.     case SYS_ARG:
  181.       args[arg_index++] = context->regs[0].word << 16 | context->regs[1].word;
  182.       break;
  183.     case SYS_exit:
  184.       context->exception = SIM_DONE;
  185.       ret = args[0];
  186.       arg_index = 0;
  187.       break;
  188.     case SYS_close:
  189.       ret = close ((int) (args[0]));
  190.       arg_index = 0;
  191.       break;
  192.     case SYS_creat:
  193.       ret = creat (aptr (args[0]), args[1]);
  194.       arg_index = 0;
  195.       break;
  196.     case SYS_isatty:
  197.       ret =
  198.     isatty (args[0]);
  199.       arg_index = 0;
  200.       break;
  201.     case SYS_open:
  202.       ret = open (aptr (args[0]), args[1], args[2]);
  203.       arg_index = 0;
  204.       break;
  205.       case
  206.     SYS_lseek:
  207.       ret = lseek (args[0], (off_t) args[1], args[2]);
  208.       arg_index =
  209.     0;
  210.       break;
  211.     case SYS_read:
  212.       ret = read (args[0], aptr (args[1]), args[2]);
  213.       arg_index = 0;
  214.       break;
  215.     case SYS_write:
  216.       ret = write (args[0],aptr (args[1]), args[2]);
  217.       arg_index = 0;
  218.       break;
  219.     case SYS_time:
  220.       {
  221.     int
  222.       dst = args[0];
  223.  
  224.     ret = time (0);
  225.     if (dst)
  226.       {
  227.         put_long_mem_da (context,
  228.                  sitoptr (dst), ret);
  229.       }
  230.     retnext = ret;
  231.     ret = retnext >> 16;
  232.     arg_index =
  233.       0;
  234.       }
  235.       break;
  236.     case SYS_fstat:
  237.       {
  238.     int buf;
  239.     struct stat host_stat;
  240.     fd =
  241.       args[0];
  242.     buf = sitoptr (args[1]);
  243.     ret = fstat (fd, &host_stat);
  244.     buf = put_short (context, buf, host_stat.st_dev);
  245.     buf = put_short (context, buf, host_stat.st_ino);
  246.     buf = put_short (context, buf, host_stat.st_mode);
  247.     buf = put_short (context, buf, host_stat.st_nlink);
  248.     buf = put_short (context, buf, host_stat.st_uid);
  249.     buf = put_short (context, buf, host_stat.st_uid);
  250.     buf = put_short (context, buf, host_stat.st_rdev);
  251.     buf = put_long (context, buf, host_stat.st_size);
  252.     buf = put_long (context, buf, host_stat.st_atime);
  253.     arg_index = 0;
  254.       } break;
  255.     default:
  256.     case SYS_link:
  257.       context->exception = SIM_BAD_SYSCALL;
  258.       arg_index = 0;
  259.       break;
  260.     }
  261.   context->regs[2].word = ret;
  262.   context->regs[3].word = retnext;
  263.   context->regs[5].word = errno;
  264.  
  265.  
  266.   /* support for the stdcall calling convention */
  267.   context->regs[6].word = retnext;
  268.   context->regs[7].word = ret;
  269.  
  270.   errno = olderrno;
  271. }
  272.  
  273. #undef get_word_mem_da
  274.  
  275. int
  276. get_word_mem_da (context, addr)
  277.      sim_state_type *context;
  278.      int addr;
  279. {
  280.   return (get_byte_mem_da (context, addr) << 8) | (get_byte_mem_da (context, addr + 1));
  281.  
  282. }
  283.  
  284. #undef get_word_reg
  285. int 
  286. get_word_reg (context, reg) sim_state_type
  287. * context;
  288.      int reg;
  289. {
  290.   return context->regs[reg].word;
  291. }
  292.  
  293. #ifdef LOG
  294. int log[64 * 1024];
  295.  
  296. #endif
  297.  
  298. void
  299. tm_store_register (regno, value)
  300.      int regno;
  301.      int value;
  302. {
  303.   switch
  304.     (regno)
  305.     {
  306.     case REG_PC:
  307.       the_state.sometimes_pc = value;
  308.       break;
  309.  
  310.     default:
  311.       put_word_reg (&the_state, regno, value);
  312.     }
  313. }
  314.  
  315. void
  316. swap_long (buf, val)
  317.      char *buf;
  318.      int val;
  319. {
  320.   buf[0] = val >> 24;
  321.   buf[1] = val >> 16;
  322.   buf[2] = val >> 8;
  323.   buf[3] = val >> 0;
  324. }
  325.  
  326. void
  327. swap_word (buf, val)
  328.      char *buf;
  329.      int val;
  330. {
  331.   buf[0] = val >> 8;
  332.   buf[1] = val >> 0;
  333. }
  334.  
  335. void
  336. tm_fetch_register (regno, buf)
  337.      int regno;
  338.      char *buf;
  339. {
  340.   switch
  341.     (regno)
  342.     {
  343.     case REG_CYCLES:
  344.       swap_long (buf, the_state.cycles);
  345.       break;
  346.     case REG_INSTS:
  347.       swap_long (buf, the_state.insts);
  348.       break;
  349.       case
  350.     REG_TIME:
  351.       swap_long (buf, the_state.ticks);
  352.       break;
  353.     case REG_PC:
  354.       swap_long (buf, the_state.sometimes_pc);
  355.       break;
  356.     case REG_SP:
  357.       {
  358.     if (sim_z8001_mode)
  359.       {
  360.         swap_long (buf, get_long_reg (&the_state, 14));
  361.       }
  362.     else
  363.       {
  364.         swap_long (buf, get_word_reg (&the_state, 15));
  365.       }
  366.       }
  367.       break;
  368.       case
  369.     REG_FP:
  370.       {
  371.     if (sim_z8001_mode)
  372.       {
  373.         swap_long (buf, get_long_reg
  374.                (&the_state, 10));
  375.       }
  376.     else
  377.       {
  378.         swap_long (buf,
  379.                get_word_reg (&the_state, 10));
  380.       }
  381.       }
  382.       break;
  383.     default:
  384.       {
  385.     swap_word (buf,
  386.            get_word_reg (&the_state, regno));
  387.       }
  388.     }
  389. }
  390.  
  391. void
  392. tm_resume (step)
  393.      int step;
  394. {
  395.   int now = get_now ();
  396.   struct op_info
  397.    *p;
  398.   int word;
  399.   int pc;
  400.   extern int (*(sfop_table[])) ();
  401.   extern int (*(bfop_table[])) ();
  402.   int (*((*table))) ();
  403.   sim_state_type *context = &the_state;
  404.  
  405.   if (step)
  406.     {
  407.       context->exception = SIM_SINGLE_STEP;
  408.     }
  409.   else
  410.     {
  411.       context->exception = 0;
  412.     }
  413.  
  414.   pc = context->sometimes_pc;
  415.   if (sim_z8001_mode)
  416.     {
  417.       table = bfop_table;
  418.       pc = MAP_PHYSICAL_TO_LOGICAL (pc);
  419.     }
  420.   else
  421.     {
  422.       table = sfop_table;
  423.     }
  424.  
  425.  
  426.   do
  427.     {
  428.       word = get_word_mem_da (context, pc);
  429.       p = op_info_table + word;
  430.  
  431. #ifdef LOG
  432.       log[word]++;
  433. #endif
  434.       pc = table[p->exec] (context, pc, word);
  435.       context->insts++;
  436.  
  437.     }
  438.   while (!context->exception);
  439.  
  440.  
  441.  
  442.   context->sometimes_pc = MAP_LOGICAL_TO_PHYSICAL (pc);
  443.   context->ticks += get_now () - now;
  444. }
  445.  
  446. int
  447. tm_signal ()
  448. {
  449.   return the_state.exception;
  450. }
  451.  
  452. void
  453. tm_info_print (x)
  454.      sim_state_type *x;
  455. {
  456.   double timetaken = (double) x->ticks / (double) now_persec ();
  457.   double virttime = x->cycles / 4.0e6;
  458.  
  459.   printf ("instructions executed            : %9d\n", x->insts);
  460.   printf ("cycles counted                   : %9d \n", x->cycles);
  461.   printf ("cycles / inst                    : %9.1f \n", (double) x->cycles / (double) x->insts);
  462.   printf ("virtual time taked (at 4 Mhz)    : %9.1f \n", virttime);
  463.   printf ("real time taken                  : %9.1f \n", timetaken);
  464.  
  465.   if (timetaken)
  466.     {
  467.       printf ("virtual instructions per second  : %9.1f\n", x->insts / timetaken);
  468.       printf ("emulation speed                  : %9.1f%%\n", virttime / timetaken * 100.0);
  469.     }
  470. #ifdef LOG
  471.   {
  472.     extern int quick[];
  473.  
  474.     for (i = 0; quick[i]; i++)
  475.       {
  476.     log[quick[i]] += 100000;
  477.       }
  478.   }
  479.  
  480.   for (i = 0; i < 64 * 1024; i++)
  481.     {
  482.       if (log[i])
  483.     {
  484.       printf ("            /*%7d*/ 0x%x,\n", log[i], i);
  485.     }
  486.     }
  487. #endif
  488.  
  489. }
  490.  
  491. int
  492. sim_trace ()
  493. {
  494.   int i;
  495.   char buffer[10];
  496.   int r;
  497.  
  498.   printf ("\n");
  499.   for (r = 0; r < 16; r++)
  500.     {
  501.       int m;
  502.  
  503.       printf ("r%2d", r);
  504.       printf ("=%04x ", get_word_reg (&the_state,
  505.                       r));
  506.       for (m = -4; m < 8; m++)
  507.     {
  508.       if (m == 0)
  509.         printf (">");
  510.       printf ("%04x ",
  511.           get_word_mem_da (&the_state, (0xfffe & get_word_reg (&the_state, r)) + m * 2));
  512.     }
  513.       printf ("\n");
  514.     }
  515.  
  516.   printf ("\n");
  517.   printf ("%9d %9d %08x ", the_state.cycles,
  518.       the_state.insts, the_state.sometimes_pc);
  519.  
  520.   for (i = 0; i < 6; i++)
  521.     {
  522.       buffer[i] = get_byte_mem_da (&the_state,
  523.                    the_state.sometimes_pc + i);
  524.     }
  525.  
  526.   print_insn_z8001 (the_state.sometimes_pc, buffer, stdout);
  527.   printf
  528.     ("\n");
  529.   tm_resume (1);
  530.   if (the_state.exception != SIM_SINGLE_STEP)
  531.     return 1;
  532.   return 0;
  533. }
  534.  
  535. void
  536. tm_state (x)
  537.      sim_state_type *x;
  538. {
  539.   *x = the_state;
  540. }
  541.  
  542. void
  543. tm_exception (x)
  544.      int x;
  545. {
  546.   the_state.exception = x;
  547. }
  548.  
  549. int
  550. tm_read_byte (x)
  551.      int x;
  552. {
  553.   x &= 0x3f00ffff;
  554.   return sim_read_byte (&the_state, x);
  555. }
  556.  
  557. void
  558. tm_write_byte (x, y)
  559.      int x, y;
  560. {
  561.   x &= 0x3f00ffff;
  562.   sim_write_byte (&the_state, x, y);
  563. }
  564.  
  565. #define SIGN(x) ((x) & MASK)
  566. normal_flags_32(context,d,sa,sb,sub)
  567. sim_state_type *context;
  568. unsigned int d;
  569. unsigned int sa;
  570. unsigned int sb;
  571. unsigned int sub;
  572. {
  573. #define MASK (1<<31)
  574.   context->broken_flags = 0;    
  575.   if (sub)                        
  576.     PSW_CARRY = sa < sb;         
  577.   else                 
  578.     PSW_CARRY = d < sa;         
  579.   if (sub)
  580.     PSW_OVERFLOW = (SIGN(sa) != SIGN(sb)) && (SIGN(d) == SIGN(sb));
  581.   else
  582.     PSW_OVERFLOW = (SIGN(sa) == SIGN(sb)) && (SIGN(d) != SIGN(sb));
  583.  
  584.   PSW_SIGN = ((int)d) <0; 
  585.   PSW_ZERO = d == 0;
  586. }
  587.  
  588. normal_flags_16(context,d,sal,sbl,sub)
  589. sim_state_type *context;
  590. unsigned  int d;
  591. unsigned  int sal;
  592. unsigned  int sbl;
  593. unsigned short int sub;
  594. {
  595.   unsigned short sa = sal;
  596.   unsigned short sb = sbl;
  597. #define MASK (1<<15)
  598.   context->broken_flags = 0;    
  599.   if (sub)                        
  600.     PSW_CARRY = sal < sbl;         
  601.   else             
  602.     PSW_CARRY = (d & 0x10000) != 0;
  603.  
  604.   if (sub)
  605.     PSW_OVERFLOW = (SIGN(sa) != SIGN(sb)) && (SIGN(d) == SIGN(sb));
  606.   else
  607.     PSW_OVERFLOW = (SIGN(sa) == SIGN(sb)) && (SIGN(d) != SIGN(sb));
  608.  
  609.   PSW_SIGN = ((short int)d) <0; 
  610.   PSW_ZERO = ((short)d) == 0;
  611. }
  612.  
  613. normal_flags_8(context,d,sa,sb,sub)
  614. sim_state_type *context;
  615. unsigned char d;
  616. unsigned char sa;
  617. unsigned char sb;
  618. unsigned char sub;
  619. {
  620. #define MASK (1<<7)
  621.   context->broken_flags = 0;    
  622.   if (sub)                        
  623.     PSW_CARRY = sa < sb;         
  624.   else                 
  625.     PSW_CARRY = d < sa;         
  626.   if (sub)
  627.     PSW_OVERFLOW = (SIGN(sa) != SIGN(sb)) && (SIGN(d) == SIGN(sb));
  628.   else
  629.     PSW_OVERFLOW = (SIGN(sa) == SIGN(sb)) && (SIGN(d) != SIGN(sb));
  630.   PSW_SIGN = ((char)d) <0; 
  631.   PSW_ZERO = d == 0;
  632. }
  633.  
  634.  
  635. static int
  636. is_cond_true (context, c)
  637.      sim_state_type *context;
  638.      int c;
  639. {
  640.   switch (c)
  641.     {
  642.     case T:
  643.       return 1;
  644.     case F:
  645.       return 0;            /* F */
  646.     case LE:
  647.       return (PSW_ZERO | (PSW_SIGN ^ PSW_OVERFLOW)) & 1;    /*LE */
  648.     case GT:
  649.       return (~(PSW_ZERO | (PSW_SIGN ^ PSW_OVERFLOW))) & 1;    /*GT */
  650.     case 0x5:
  651.       return (PSW_SIGN & 1);    /* sign */
  652.     case 0xd:
  653.       return (~(PSW_SIGN)) & 1;    /* not sign */
  654.     case 0x3:
  655.       return ((PSW_CARRY | PSW_ZERO) & 1);    /* ule*/
  656.     case UGT:
  657.       return ((~(PSW_CARRY | PSW_ZERO)) & 1);    /* ugt */
  658.     case 0x4:
  659.       return (PSW_OVERFLOW & 1);/* overflow */
  660.     case 0xc:
  661.       return (~(PSW_OVERFLOW)) & 1;    /* not overflow */
  662.     case LT:
  663.       return (PSW_SIGN ^ PSW_OVERFLOW) & 1;    /* LT */
  664.     case GE:
  665.       return (~(PSW_SIGN ^ PSW_OVERFLOW)) & 1;    /* GE */
  666.     case EQ:
  667.       return (PSW_ZERO) & 1;    /* zero */
  668.     case NE:
  669.       return ((~PSW_ZERO) & 1);    /* not zero */
  670.     case 0x7:
  671.       return (PSW_CARRY) & 1;    /* carry */
  672.     case 0xf:
  673.       return (~PSW_CARRY) & 1;    /* not carry */
  674.     default:
  675.       abort ();
  676.     }
  677. }
  678.  
  679. int
  680. COND (context, c)
  681.      sim_state_type *context;
  682.      int c;
  683. {
  684.   if (c == 8)
  685.     return 1;
  686.  
  687.   /* We can calculate what the flags would have been by
  688.      looking at the src and dst and size of the operation */
  689.  
  690.   if (context->broken_flags)
  691.     {
  692.       int slow = 0;
  693.       int size;
  694.       int dst;
  695.       int srca;
  696.       int srcb;
  697.       int mask;
  698.       int ans;
  699.  
  700.       /* see if we can short-cut the nasty flag calcs */
  701.  
  702.       switch (size = context->size)
  703.     {
  704.      default:
  705.       abort();
  706.       return 0;
  707.     case 8:
  708.       srca = (char) (context->srca);
  709.       srcb = (char) (context->srcb);
  710.       dst = (char) (context->dst);
  711.       mask = 0xff;
  712.       break;
  713.     case 16:
  714.       srca = (short) (context->srca);
  715.       srcb = (short) (context->srcb);
  716.       dst = (short) (context->dst);
  717.       mask = 0xffff;
  718.       break;
  719.     case 32:
  720.       srca = (long) (context->srca);
  721.       srcb = (long) (context->srcb);
  722.       dst = (long) (context->dst);
  723.       mask = 0xffffffff;
  724.       break;
  725.     }
  726.  
  727.       switch (c)
  728.     {
  729.     case T:
  730.       return 1;
  731.     case F:
  732.       return 0;
  733.     case EQ:
  734.       return !dst;
  735.     case NE:
  736.       return dst;
  737.     case GT:
  738.       ans = ((dst)) > 0;
  739.       if (slow)
  740.         {
  741.           if (is_cond_true (context, c) != ans)
  742.         abort ();
  743.         }
  744.       return ans;
  745.     case LE:
  746.       ans = ((dst)) <= 0;
  747.       if (slow)
  748.         {
  749.           if (is_cond_true (context, c) != ans)
  750.         abort ();
  751.         }
  752.       return ans;
  753.     case GE:
  754.       ans = ((dst)) >= 0;
  755.       if (slow)
  756.         {
  757.           if (is_cond_true (context, c) != ans)
  758.         abort ();
  759.         }
  760.       return ans;
  761.     case LT:
  762.       ans = ((dst)) < 0;
  763.       if (slow)
  764.         {
  765.           if (is_cond_true (context, c) != ans)
  766.         abort ();
  767.         }
  768.       return ans;
  769.     default:
  770.       break;
  771.     }
  772.  
  773.       /* Can't fake it, we'll have to work out the flags the
  774.          hard way */
  775.  
  776.       makeflags (context, mask);
  777.     }
  778.  
  779.   /* don't know how to fake a test, inspect the flags
  780.      the hard way */
  781.  
  782.   return is_cond_true (context, c);
  783. }
  784.