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 / inlines.h < prev    next >
C/C++ Source or Header  |  1995-08-01  |  10KB  |  487 lines
  1. /* inline functions for Z8KSIM
  2.    Copyright (C) 1992, 1993 Free Software Foundation, Inc.
  3.  
  4. This file is part of Z8KSIM
  5.  
  6. GNU CC 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. GNU CC 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. #ifndef INLINE
  21. #define INLINE
  22. #endif
  23. #define UGT 0x0b
  24. #define ULE 0x03
  25. #define ULT 0x07
  26. #define UGE 0x0f
  27. #define SLOW 0
  28. #define T 0x8
  29. #define F 0x0
  30. #define LT 0x1
  31. #define GT 0xa
  32. #define LE 0x2
  33. #define EQ 0x6
  34. #define NE 0xe
  35. #define GE 0x9
  36.  
  37.  static int is_cond_true PARAMS((sim_state_type *context, int c)); 
  38.  static void makeflags PARAMS((sim_state_type *context, int mask)); 
  39.  
  40. static INLINE
  41. long
  42. sitoptr (si)
  43. long si;
  44. {
  45.   return ((si & 0xff000000) >> 8) | (si & 0xffff);
  46. }
  47. static INLINE long
  48. ptrtosi (ptr)
  49. long ptr;
  50. {
  51.   return ((ptr & 0xff0000) << 8) | (ptr & 0xffff);
  52. }
  53.  
  54. static INLINE
  55. void 
  56. put_long_reg (context, reg, val)
  57.      sim_state_type *context;
  58.      int reg;
  59.      int val;
  60. {
  61.   context->regs[reg].word = val >> 16;
  62.   context->regs[reg + 1].word = val;
  63. }
  64.  
  65. static INLINE
  66. void 
  67. put_quad_reg (context, reg, val1, val2)
  68.      sim_state_type *context;
  69.      int reg;
  70.      int val1;
  71.      int val2;
  72. {
  73.   context->regs[reg].word = val2 >> 16;
  74.   context->regs[reg + 1].word = val2;
  75.   context->regs[reg + 2].word = val1 >> 16;
  76.   context->regs[reg + 3].word = val1;
  77. }
  78.  
  79. static INLINE
  80. void 
  81. put_word_reg (context, reg, val)
  82.      sim_state_type *context;
  83.      int reg;
  84.      int val;
  85. {
  86.   context->regs[reg].word = val;
  87. }
  88.  
  89. static INLINE
  90. SItype get_long_reg (context, reg)
  91.      sim_state_type *context;
  92.      int reg;
  93. {
  94.   USItype lsw = context->regs[reg + 1].word;
  95.   USItype msw = context->regs[reg].word;
  96.  
  97.   return (msw << 16) | lsw;
  98. }
  99.  
  100. #ifdef __GNUC__
  101. static INLINE
  102. struct UDIstruct
  103. get_quad_reg (context, reg)
  104.      sim_state_type *context;
  105.      int reg;
  106. {
  107.   UDItype res;
  108.   USItype lsw = get_long_reg (context, reg + 2);
  109.   USItype msw = get_long_reg (context, reg);
  110.  
  111.   res.low = lsw;
  112.   res.high = msw;
  113.   return res;
  114. }
  115.  
  116. #endif
  117.  
  118. static INLINE void
  119. put_byte_mem_da (context, addr, value)
  120.      sim_state_type *context;
  121.      int addr;
  122.      int value;
  123. {
  124.   ((unsigned char *) (context->memory))[addr] = value;
  125. }
  126.  
  127. static INLINE
  128. void 
  129. put_byte_reg (context, reg, val)
  130.      sim_state_type *context;
  131.      int reg;
  132.      int val;
  133. {
  134.   int old = context->regs[reg & 0x7].word;
  135.   if (reg & 0x8)
  136.     {
  137.       old = old & 0xff00 | (val & 0xff);
  138.     }
  139.   else
  140.     {
  141.       old = old & 0x00ff | (val << 8);
  142.     }
  143.   context->regs[reg & 0x7].word = old;      
  144. }
  145.  
  146. static INLINE
  147. int 
  148. get_byte_reg (context, reg)
  149.      sim_state_type *context;
  150.      int reg;
  151. {
  152.   if (reg & 0x8)
  153.     return  context->regs[reg & 0x7].word & 0xff;
  154.   else
  155.     return  (context->regs[reg & 0x7].word >> 8) & 0xff;
  156. }
  157.  
  158. static INLINE
  159. void 
  160. put_word_mem_da (context, addr, value)
  161.      sim_state_type *context;
  162.      int addr;
  163.      int value;
  164. {
  165.   if (addr & 1)
  166.     {
  167.       context->exception = SIM_BAD_ALIGN;
  168.       addr &= ~1;
  169.     }
  170.   put_byte_mem_da(context, addr, value>>8);
  171.   put_byte_mem_da(context, addr+1, value);
  172. }
  173.  
  174. static INLINE unsigned char
  175. get_byte_mem_da (context, addr)
  176.      sim_state_type *context;
  177.      int addr;
  178. {
  179.   return ((unsigned char *) (context->memory))[addr];
  180. }
  181.  
  182.  
  183. #if 0
  184. #define get_word_mem_da(context,addr)\
  185.  *((unsigned short*)((char*)((context)->memory)+(addr)))
  186.  
  187. #else
  188. #define get_word_mem_da(context,addr) (get_byte_mem_da(context, addr) << 8) | (get_byte_mem_da(context,addr+1))
  189. #endif
  190.  
  191. #define get_word_reg(context,reg) (context)->regs[reg].word
  192.  
  193. static INLINE
  194. SItype
  195. get_long_mem_da (context, addr)
  196.      sim_state_type *context;
  197.      int addr;
  198. {
  199.   USItype lsw = get_word_mem_da(context,addr+2);
  200.   USItype msw =  get_word_mem_da(context, addr);
  201.  
  202.   return (msw << 16) + lsw;
  203. }
  204.  
  205. static INLINE
  206. void 
  207. put_long_mem_da (context, addr, value)
  208.      sim_state_type *context;
  209.      int addr;
  210.      int value;
  211. {
  212.   put_word_mem_da(context,addr, value>>16);
  213.   put_word_mem_da(context,addr+2, value);
  214. }
  215.  
  216. static INLINE
  217. int 
  218. get_word_mem_ir (context, reg)
  219.      sim_state_type *context;
  220.      int reg;
  221. {
  222.   return get_word_mem_da (context, get_word_reg (context, reg));
  223. }
  224.  
  225. static INLINE
  226. void 
  227. put_word_mem_ir (context, reg, value)
  228.      sim_state_type *context;
  229.      int reg;
  230.      int value;
  231. {
  232.  
  233.   put_word_mem_da (context, get_word_reg (context, reg), value);
  234. }
  235.  
  236. static INLINE
  237. int 
  238. get_byte_mem_ir (context, reg)
  239.      sim_state_type *context;
  240.      int reg;
  241. {
  242.   return get_byte_mem_da (context, get_word_reg (context, reg));
  243. }
  244.  
  245. static INLINE
  246. void 
  247. put_byte_mem_ir (context, reg, value)
  248.      sim_state_type *context;
  249.      int reg;
  250.      int value;
  251. {
  252.   put_byte_mem_da (context, get_word_reg (context, reg), value);
  253. }
  254.  
  255. static INLINE
  256. int 
  257. get_long_mem_ir (context, reg)
  258.      sim_state_type *context;
  259.      int reg;
  260. {
  261.   return get_long_mem_da (context, get_word_reg (context, reg));
  262. }
  263.  
  264. static INLINE
  265. void 
  266. put_long_mem_ir (context, reg, value)
  267.      sim_state_type *context;
  268.      int reg;
  269.      int value;
  270. {
  271.  
  272.   put_long_mem_da (context, get_word_reg (context, reg), value);
  273. }
  274.  
  275. static INLINE
  276. void 
  277. put_long_mem_x (context, base, reg, value)
  278.      sim_state_type *context;
  279.      int base;
  280.      int reg;
  281.      int value;
  282. {
  283.   put_long_mem_da (context, get_word_reg (context, reg) + base, value);
  284. }
  285.  
  286. static INLINE
  287. void 
  288. put_word_mem_x (context, base, reg, value)
  289.      sim_state_type *context;
  290.      int base;
  291.      int reg;
  292.      int value;
  293. {
  294.   put_word_mem_da (context, get_word_reg (context, reg) + base, value);
  295. }
  296.  
  297. static INLINE
  298. void 
  299. put_byte_mem_x (context, base, reg, value)
  300.      sim_state_type *context;
  301.      int base;
  302.      int reg;
  303.      int value;
  304. {
  305.   put_byte_mem_da (context, get_word_reg (context, reg) + base, value);
  306. }
  307.  
  308. static INLINE
  309. int 
  310. get_word_mem_x (context, base, reg)
  311.      sim_state_type *context;
  312.      int base;
  313.      int reg;
  314. {
  315.   return get_word_mem_da (context, base + get_word_reg (context, reg));
  316. }
  317.  
  318. static INLINE
  319. int 
  320. get_byte_mem_x (context, base, reg)
  321.      sim_state_type *context;
  322.      int base;
  323.      int reg;
  324. {
  325.   return get_byte_mem_da (context, base + get_word_reg (context, reg));
  326. }
  327.  
  328. static INLINE
  329. int 
  330. get_long_mem_x (context, base, reg)
  331.      sim_state_type *context;
  332.      int base;
  333.      int reg;
  334. {
  335.   return get_long_mem_da (context, base + get_word_reg (context, reg));
  336. }
  337.  
  338.  
  339. static
  340. void
  341. makeflags (context, mask)
  342.      sim_state_type *context;
  343.      int mask;
  344. {
  345.  
  346.   PSW_ZERO = (context->dst & mask) == 0;
  347.   PSW_SIGN = (context->dst >> (context->size - 1));
  348.  
  349.   if (context->broken_flags == TST_FLAGS)
  350.     {
  351.       extern char the_parity[];
  352.  
  353.       if (context->size == 8)
  354.     {
  355.       PSW_OVERFLOW = the_parity[context->dst & 0xff];
  356.     }
  357.     }
  358.   else
  359.     {
  360.       /* Overflow is set if both operands have the same sign and the
  361.          result is of different sign.
  362.  
  363.          V =  A==B && R!=B  jumping logic
  364.          (~(A^B))&(R^B)
  365.          V =  (A^B)^(R^B)   boolean
  366.          */
  367.  
  368.       PSW_OVERFLOW =
  369.     ((
  370.        (~(context->srca ^ context->srcb)
  371.         & (context->srca ^ context->dst))
  372.      ) >> (context->size - 1)
  373.     );
  374.  
  375.       if (context->size < 32)
  376.     {
  377.       PSW_CARRY = ((context->dst >> context->size)) & 1;
  378.     }
  379.       else
  380.     {
  381.       /* carry is set when the result is smaller than a source */
  382.  
  383.  
  384.       PSW_CARRY =  (unsigned) context->dst > (unsigned) context->srca ;
  385.  
  386.     }
  387.     }
  388.   context->broken_flags = 0;
  389. }
  390.  
  391.  
  392. /* There are two ways to calculate the flags.  We can
  393.    either always calculate them and so the cc will always
  394.    be correct, or we can only keep the arguments around and
  395.    calc the flags when they're actually going to be used. */
  396.  
  397. /* Right now we always calc the flags - I think it may be faster*/
  398.  
  399.  
  400. #define NORMAL_FLAGS(c,s,d,sa,sb,sub)     \
  401.     if (s == 8)                \
  402.       normal_flags_8(c,d,sa,sb,sub); \
  403.     else if (s == 16)                \
  404.       normal_flags_16(c,d,sa,sb,sub); \
  405.     else if (s == 32)                \
  406.       normal_flags_32(c,d,sa,sb,sub); 
  407.  
  408. static INLINE
  409. void 
  410. normal_flags (context, size, dst, srca, srcb)
  411.      sim_state_type *context;
  412.      int size;
  413.      int dst;
  414.      int srca;
  415.      int srcb;
  416. {
  417.   context->srca = srca;
  418.   context->srcb = srcb;
  419.   context->dst = dst;
  420.   context->size = size;
  421.   context->broken_flags = CMP_FLAGS;
  422. }
  423.  
  424. static INLINE
  425. void 
  426. TEST_NORMAL_FLAGS (context, size, dst)
  427.      sim_state_type *context;
  428.      int size;
  429.      int dst;
  430. {
  431.   context->dst = dst;
  432.   context->size = size;
  433.   context->broken_flags = TST_FLAGS;
  434. }
  435.  
  436. static INLINE
  437. void 
  438. put_ptr_long_reg (context, reg, val)
  439.      sim_state_type *context;
  440.      int reg;
  441.      int val;
  442. {
  443.   context->regs[reg].word = (val >> 8) & 0x7f00;
  444.   context->regs[reg + 1].word = val;
  445. }
  446.  
  447. static INLINE
  448. long 
  449. get_ptr_long_reg (context, reg)
  450.      sim_state_type *context;
  451.      int reg;
  452. {
  453.   int val;
  454.  
  455.   val = (context->regs[reg].word << 8) | context->regs[reg + 1].word;
  456.   return val;
  457. }
  458.  
  459. static INLINE
  460. long 
  461. get_ptr_long_mem_ir (context, reg)
  462. sim_state_type *context;
  463. int reg;
  464. {
  465.   return sitoptr (get_long_mem_da (context, get_ptr_long_reg (context, reg)));
  466. }
  467.  
  468. static INLINE
  469. long 
  470. get_ptr_long_mem_da (context, addr)
  471. sim_state_type *context;
  472. long addr; 
  473. {
  474.   return sitoptr (get_long_mem_da (context, addr));
  475. }
  476.  
  477. static INLINE
  478. void 
  479. put_ptr_long_mem_da (context, addr, ptr)
  480. sim_state_type *context;
  481. long addr; 
  482. long ptr;
  483. {
  484.   put_long_mem_da (context, addr, ptrtosi (ptr));
  485.  
  486. }
  487.