OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [sim/] [testsuite/] [common/] [alu-n-tst.h] - Blame information for rev 355

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn 
#ifndef N
2 
#error "N must be #defined"
3 
#endif
4 
 
5 
#include "symcat.h"
6 
 
7 
/* NOTE: see end of file for #undef of these macros */
8 
#define unsignedN    XCONCAT2(unsigned,N)
9 
#define MAX_INT      XCONCAT2(MAX_INT,N)
10 
#define MIN_INT      XCONCAT2(MIN_INT,N)
11 
#define alu_N_tests     XCONCAT3(alu_,N,_tests)
12 
#define do_alu_N_tests  XCONCAT3(do_alu_,N,_tests)
13 
#define OP_BEGIN     XCONCAT3(ALU,N,_BEGIN)
14 
#define OP_ADDC      XCONCAT3(ALU,N,_ADDC)
15 
#define OP_ADDC_C    XCONCAT3(ALU,N,_ADDC_C)
16 
#define OP_SUBC      XCONCAT3(ALU,N,_SUBC)
17 
#define OP_SUBB      XCONCAT3(ALU,N,_SUBB)
18 
#define OP_SUBB_B    XCONCAT3(ALU,N,_SUBB_B)
19 
#define OP_SUBC_X    XCONCAT3(ALU,N,_SUBC_X)
20 
#define OP_NEGC      XCONCAT3(ALU,N,_NEGC)
21 
#define OP_NEGB      XCONCAT3(ALU,N,_NEGB)
22 
#define HAD_CARRY_BORROW    (XCONCAT3(ALU,N,_HAD_CARRY_BORROW) != 0)
23 
#define HAD_OVERFLOW (XCONCAT3(ALU,N,_HAD_OVERFLOW) != 0)
24 
#define RESULT          XCONCAT3(ALU,N,_RESULT)
25 
#define CARRY_BORROW_RESULT    XCONCAT3(ALU,N,_CARRY_BORROW_RESULT)
26 
#define OVERFLOW_RESULT XCONCAT3(ALU,N,_OVERFLOW_RESULT)
27 
#define do_op_N      XCONCAT2(do_op_,N)
28 
 
29 
 
30 
void
31 
do_op_N (const alu_test *tst)
32 
{
33 
  const alu_op *op;
34 
  int borrow_p = 0;
35 
  OP_BEGIN (tst->begin);
36 
  print_hex (tst->begin, N);
37 
  for (op = tst->ops; op->op != NULL; op++)
38 
    {
39 
      printf (" %s ", op->op);
40 
      print_hex (op->arg, N);
41 
      if (strcmp (op->op, "ADDC") == 0)
42 
        OP_ADDC (op->arg);
43 
      else if (strcmp (op->op, "ADDC_C0") == 0)
44 
        OP_ADDC_C (op->arg, 0);
45 
      else if (strcmp (op->op, "ADDC_C1") == 0)
46 
        OP_ADDC_C (op->arg, 1);
47 
      else if (strcmp (op->op, "SUBC") == 0)
48 
        OP_SUBC (op->arg);
49 
      else if (strcmp (op->op, "SUBC_X0") == 0)
50 
        OP_SUBC_X (op->arg, 0);
51 
      else if (strcmp (op->op, "SUBC_X1") == 0)
52 
        OP_SUBC_X (op->arg, 1);
53 
      else if (strcmp (op->op, "SUBB") == 0)
54 
        {
55 
          OP_SUBB (op->arg);
56 
          borrow_p ++;
57 
        }
58 
      else if (strcmp (op->op, "SUBB_B0") == 0)
59 
        {
60 
          OP_SUBB_B (op->arg, 0);
61 
          borrow_p ++;
62 
        }
63 
      else if (strcmp (op->op, "SUBB_B1") == 0)
64 
        {
65 
          OP_SUBB_B (op->arg, 1);
66 
          borrow_p ++;
67 
        }
68 
      else if (strcmp (op->op, "NEGC") == 0)
69 
        OP_NEGC ();
70 
      else if (strcmp (op->op, "NEGB") == 0)
71 
        {
72 
          OP_NEGB ();
73 
          borrow_p ++;
74 
        }
75 
      else
76 
        {
77 
          printf (" -- operator unknown\n");
78 
          abort ();
79 
        }
80 
    }
81 
  printf (" = ");
82 
  print_hex (tst->result, N);
83 
  if (borrow_p)
84 
    printf (" B:%d", tst->carry_borrow);
85 
  else
86 
    printf (" C:%d", tst->carry_borrow);
87 
  printf (" V:%d", tst->overflow);
88 
  if (tst->carry_borrow != HAD_CARRY_BORROW)
89 
    {
90 
      if (borrow_p)
91 
        printf (" -- borrow (%d) wrong", HAD_CARRY_BORROW);
92 
      else
93 
        printf (" -- carry (%d) wrong", HAD_CARRY_BORROW);
94 
      errors ++;
95 
    }
96 
  if (tst->overflow != HAD_OVERFLOW)
97 
    {
98 
      printf (" -- overflow (%d) wrong", HAD_OVERFLOW);
99 
      errors ++;
100 
    }
101 
  if ((unsignedN) CARRY_BORROW_RESULT != (unsignedN) tst->result)
102 
    {
103 
      printf (" -- result for carry/borrow wrong ");
104 
      print_hex (CARRY_BORROW_RESULT, N);
105 
      errors ++;
106 
    }
107 
  if ((unsignedN) OVERFLOW_RESULT != (unsignedN) tst->result)
108 
    {
109 
      printf (" -- result for overflow wrong ");
110 
      print_hex (OVERFLOW_RESULT, N);
111 
      errors ++;
112 
    }
113 
  if ((unsignedN) RESULT != (unsignedN) tst->result)
114 
    {
115 
      printf (" -- result wrong ");
116 
      print_hex (RESULT, N);
117 
      errors ++;
118 
    }
119 
  printf ("\n");
120 
}
121 
 
122 
 
123 
const alu_test alu_N_tests[] = {
124 
 
125 
  /* 0 + 0; 0 + 1; 1 + 0; 1 + 1 */
126 
  { 0, { { "ADDC", 0 }, }, 0, 0, 0, },
127 
  { 0, { { "ADDC", 1 }, }, 1, 0, 0, },
128 
  { 1, { { "ADDC", 0 }, }, 1, 0, 0, },
129 
  { 1, { { "ADDC", 1 }, }, 2, 0, 0, },
130 
 
131 
  /* 0 + 0 + 0; 0 + 0 + 1; 0 + 1 + 0; 0 + 1 + 1 */
132 
  /* 1 + 0 + 0; 1 + 0 + 1; 1 + 1 + 0; 1 + 1 + 1 */
133 
  { 0, { { "ADDC_C0", 0 }, }, 0, 0, 0, },
134 
  { 0, { { "ADDC_C0", 1 }, }, 1, 0, 0, },
135 
  { 0, { { "ADDC_C1", 0 }, }, 1, 0, 0, },
136 
  { 0, { { "ADDC_C1", 1 }, }, 2, 0, 0, },
137 
  { 1, { { "ADDC_C0", 0 }, }, 1, 0, 0, },
138 
  { 1, { { "ADDC_C0", 1 }, }, 2, 0, 0, },
139 
  { 1, { { "ADDC_C1", 0 }, }, 2, 0, 0, },
140 
  { 1, { { "ADDC_C1", 1 }, }, 3, 0, 0, },
141 
 
142 
  /* */
143 
  { MAX_INT, { { "ADDC", 1 }, }, MIN_INT, 0, 1, },
144 
  { MIN_INT, { { "ADDC", -1 }, }, MAX_INT, 1, 1, },
145 
  { MAX_INT, { { "ADDC", MIN_INT }, }, -1, 0, 0, },
146 
  { MIN_INT, { { "ADDC", MAX_INT }, }, -1, 0, 0, },
147 
  { MAX_INT, { { "ADDC", MAX_INT }, }, MAX_INT << 1, 0, 1, },
148 
  { MIN_INT, { { "ADDC", MIN_INT }, }, 0, 1, 1, },
149 
  /* */
150 
  { 0, { { "ADDC_C1", -1 }, }, 0, 1, 0, },
151 
  { 0, { { "ADDC_C1", -2 }, }, -1, 0, 0, },
152 
  { -1, { { "ADDC_C1", 0 }, }, 0, 1, 0, },
153 
  { 0, { { "ADDC_C0", 0 }, }, 0, 0, 0, },
154 
  { -1, { { "ADDC_C1", -1 }, }, -1, 1, 0, },
155 
  { -1, { { "ADDC_C1", 1 }, }, 1, 1, 0, },
156 
  { 0, { { "ADDC_C1", MAX_INT }, }, MIN_INT, 0, 1, },
157 
  { MAX_INT, { { "ADDC_C1", 1 }, }, MIN_INT + 1, 0, 1, },
158 
  { MAX_INT, { { "ADDC_C1", MIN_INT }, }, 0, 1, 0, },
159 
  { MAX_INT, { { "ADDC_C1", MAX_INT }, }, (MAX_INT << 1) + 1, 0, 1, },
160 
  { MAX_INT, { { "ADDC_C0", MAX_INT }, }, MAX_INT << 1, 0, 1, },
161 
 
162 
  /* 0 - 0 */
163 
  { 0, { { "SUBC",    0 }, },  0, 1, 0, },
164 
  { 0, { { "SUBB",    0 }, },  0, 0, 0, },
165 
 
166 
  /* 0 - 1 */
167 
  { 0, { { "SUBC",    1 }, }, -1, 0, 0, },
168 
  { 0, { { "SUBB",    1 }, }, -1, 1, 0, },
169 
 
170 
  /* 1 - 0 */
171 
  { 1, { { "SUBC",    0 }, },  1, 1, 0, },
172 
  { 1, { { "SUBB",    0 }, },  1, 0, 0, },
173 
 
174 
  /* 1 - 1 */
175 
  { 1, { { "SUBC",    1 }, },  0, 1, 0, },
176 
  { 1, { { "SUBB",    1 }, },  0, 0, 0, },
177 
 
178 
  /* 0 - 0 - 0 */
179 
  { 0, { { "SUBC_X0", 0 }, }, -1, 0, 0, },
180 
  { 0, { { "SUBB_B0", 0 }, },  0, 0, 0, },
181 
 
182 
  /* 0 - 0 - 1 */
183 
  { 0, { { "SUBC_X0", 1 }, }, -2, 0, 0, },
184 
  { 0, { { "SUBB_B0", 1 }, }, -1, 1, 0, },
185 
 
186 
  /* 0 - 1 - 0 */
187 
  { 0, { { "SUBC_X1", 0 }, },  0, 1, 0, },
188 
  { 0, { { "SUBB_B1", 0 }, }, -1, 1, 0, },
189 
 
190 
  /* 0 - 1 - 1 */
191 
  { 0, { { "SUBC_X1", 1 }, }, -1, 0, 0, },
192 
  { 0, { { "SUBB_B1", 1 }, }, -2, 1, 0, },
193 
 
194 
  /* 1 - 0 - 0 */
195 
  { 1, { { "SUBC_X0", 0 }, },  0, 1, 0, },
196 
  { 1, { { "SUBB_B0", 0 }, },  1, 0, 0, },
197 
 
198 
  /* 1 - 0 - 1 */
199 
  { 1, { { "SUBC_X0", 1 }, }, -1, 0, 0, },
200 
  { 1, { { "SUBB_B0", 1 }, },  0, 0, 0, },
201 
 
202 
  /* 1 - 1 - 0 */
203 
  { 1, { { "SUBC_X1", 0 }, },  1, 1, 0, },
204 
  { 1, { { "SUBB_B1", 0 }, },  0, 0, 0, },
205 
 
206 
  /* 1 - 1 - 1 */
207 
  { 1, { { "SUBC_X1", 1 }, },  0, 1, 0, },
208 
  { 1, { { "SUBB_B1", 1 }, }, -1, 1, 0, },
209 
 
210 
  /* */
211 
  { 0,       { { "SUBC", MIN_INT }, }, MIN_INT, 0, 1, },
212 
  { MIN_INT, { { "SUBC", 1 }, }, MAX_INT, 1, 1, },
213 
  { MAX_INT, { { "SUBC", MAX_INT }, }, 0, 1, 0, },
214 
 
215 
  /* */
216 
  { 0,       { { "SUBC_X0", MIN_INT }, }, MAX_INT, 0, 0, },
217 
  { MIN_INT, { { "SUBC_X1",       0 }, }, MIN_INT, 1, 0, },
218 
  { MAX_INT, { { "SUBC_X0", MAX_INT }, },      -1, 0, 0, },
219 
 
220 
  /* */
221 
  { MAX_INT, { { "NEGC", 0 }, }, MIN_INT + 1, 0, 0, },
222 
  { MAX_INT, { { "NEGC", 0 }, }, MIN_INT + 1, 0, 0, },
223 
  { MIN_INT, { { "NEGC", 0 }, }, MIN_INT, 0, 1, },
224 
  { 0, { { "NEGC", 0 }, }, 0, 1, 0, },
225 
  { -1, { { "NEGC", 0 }, }, 1, 0, 0, },
226 
  { 1, { { "NEGC", 0 }, }, -1, 0, 0, },
227 
};
228 
 
229 
 
230 
static void
231 
do_alu_N_tests (void)
232 
{
233 
  int i;
234 
  for (i = 0; i < sizeof (alu_N_tests) / sizeof (*alu_N_tests); i++)
235 
    {
236 
      const alu_test *tst = &alu_N_tests[i];
237 
      do_op_N (tst);
238 
    }
239 
}
240 
 
241 
 
242 
#undef OP_BEGIN
243 
#undef OP_ADDC
244 
#undef OP_ADDC_C
245 
#undef OP_SUBB
246 
#undef OP_SUBC
247 
#undef OP_SUBC_X
248 
#undef OP_SUBB_B
249 
#undef HAD_OVERFLOW
250 
#undef HAD_CARRY_BORROW
251 
#undef OVERFLOW_RESULT
252 
#undef CARRY_BORROW_RESULT
253 
#undef RESULT
254 
#undef do_op_N
255 
#undef unsignedN
256 
#undef MAX_INT
257 
#undef MIN_INT
258 
#undef alu_N_tests
259 
#undef do_alu_N_tests
260 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.