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

Subversion Repositories openrisc

[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc1/] [gcc/] [testsuite/] [g++.old-deja/] [g++.mike/] [p700.C] - Blame information for rev 338

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 305 jeremybenn 
// { dg-do assemble  }
2 
// { dg-options "-Wno-deprecated" }
3 
// { dg-error "limited range of data type" "16-bit target" { target xstormy16-*-* } 0 }
4 
// prms-id: 700
5 
 
6 
//# 1 "../../../../libg++/etc/benchmarks/dhrystone.cc"
7 
 
8 
 
9 
 
10 
 
11 
 
12 
 
13 
 
14 
 
15 
 
16 
 
17 
 
18 
 
19 
 
20 
 
21 
 
22 
 
23 
 
24 
 
25 
 
26 
 
27 
 
28 
 
29 
 
30 
 
31 
 
32 
//# 1 "../../../../libg++/etc/benchmarks/Int.h" 1
33 
 
34 
 
35 
 
36 
 
37 
 
38 
 
39 
 
40 
 
41 
 
42 
 
43 
 
44 
 
45 
 
46 
 
47 
 
48 
 
49 
 
50 
 
51 
 
52 
 
53 
 
54 
 
55 
 
56 
 
57 
 
58 
 
59 
 
60 
 
61 
 
62 
 
63 
 
64 
 
65 
 
66 
 
67 
 
68 
 
69 
 
70 
 
71 
 
72 
 
73 
 
74 
 
75 
 
76 
 
77 
 
78 
 
79 
 
80 
 
81 
 
82 
 
83 
 
84 
 
85 
 
86 
 
87 
 
88 
 
89 
 
90 
 
91 
 
92 
 
93 
 
94 
 
95 
 
96 
 
97 
 
98 
 
99 
 
100 
 
101 
 
102 
 
103 
 
104 
 
105 
 
106 
 
107 
 
108 
class Int
109 
{
110 
protected:
111 
  int          rep;
112 
 
113 
 
114 
 
115 
public:
116 
               Int ();
117 
               Int (const int  b);
118 
               Int (const Int& b);
119 
              ~Int();
120 
 
121 
               operator int() const;
122 
 
123 
  inline virtual  int   val() const;
124 
 
125 
  inline virtual  void  operator  = (const int);
126 
  inline virtual  void  operator  = (const Int&);
127 
 
128 
  inline virtual  void  negate();
129 
  inline virtual  void  complement();
130 
  inline virtual  void  operator ++ ();
131 
  inline virtual  void  operator -- ();
132 
 
133 
  inline virtual  void  operator += (const Int &  );
134 
  inline virtual  void  operator -= (const Int &  );
135 
  inline virtual  void  operator *= (const Int &  );
136 
  inline virtual  void  operator /= (const Int &  );
137 
  inline virtual  void  operator %= (const Int &  );
138 
  inline virtual  void  operator |= (const Int &  );
139 
  inline virtual  void  operator &= (const Int &  );
140 
  inline virtual  void  operator ^= (const Int &  );
141 
  inline virtual  void  operator <<=(const Int &  );
142 
  inline virtual  void  operator >>=(const Int &  );
143 
 
144 
 
145 
  inline virtual  void  operator += (const int);
146 
  inline virtual  void  operator -= (const int);
147 
  inline virtual  void  operator *= (const int);
148 
  inline virtual  void  operator /= (const int);
149 
  inline virtual  void  operator %= (const int);
150 
  inline virtual  void  operator |= (const int);
151 
  inline virtual  void  operator &= (const int);
152 
  inline virtual  void  operator ^= (const int);
153 
  inline virtual  void  operator <<=(const int);
154 
  inline virtual  void  operator >>=(const int);
155 
 
156 
 
157 
};
158 
 
159 
inline  int  Int::val() const { return rep; }
160 
inline       Int::operator int() const { return val(); }
161 
 
162 
inline       Int::Int () :rep(0) {}
163 
inline       Int::Int (const int  b) :rep(b) {}
164 
inline       Int::Int (const Int& b) :rep(b.Int::val()) {}
165 
inline       Int::~Int() {}
166 
 
167 
inline  void  Int::operator  = (const int  b)
168 
{ rep = b;  ; }
169 
inline  void  Int::operator  = (const Int&  b)
170 
{ rep = b.Int::val();  ; }
171 
 
172 
inline  void  Int::complement()
173 
{ rep = ~rep;  ; }
174 
inline  void  Int::negate()
175 
{ rep = -rep;  ; }
176 
inline  void  Int::operator ++ ()
177 
{ ++rep;  ; }
178 
inline  void  Int::operator -- ()
179 
{ --rep;  ; }
180 
 
181 
inline  void  Int::operator += (const Int &   b)
182 
{ rep += b.Int::val();  ; }
183 
inline  void  Int::operator -= (const Int &   b)
184 
{ rep -= b.Int::val();  ; }
185 
inline  void  Int::operator *= (const Int &   b)
186 
{ rep *= b.Int::val();  ; }
187 
inline  void  Int::operator /= (const Int &   b)
188 
{ rep /= b.Int::val();  ; }
189 
inline  void  Int::operator %= (const Int &   b)
190 
{ rep %= b.Int::val();  ; }
191 
inline  void  Int::operator |= (const Int &   b)
192 
{ rep |= b.Int::val();  ; }
193 
inline  void  Int::operator &= (const Int &   b)
194 
{ rep &= b.Int::val();  ; }
195 
inline  void  Int::operator ^= (const Int &   b)
196 
{ rep ^= b.Int::val();  ; }
197 
inline  void  Int::operator <<=(const Int &   b)
198 
{ rep <<= b.Int::val();  ; }
199 
inline  void  Int::operator >>=(const Int &   b)
200 
{ rep >>= b.Int::val();  ; }
201 
 
202 
 
203 
 
204 
inline  void  Int::operator += (const int b)
205 
{ rep += b;  ; }
206 
inline  void  Int::operator -= (const int b)
207 
{ rep -= b;  ; }
208 
inline  void  Int::operator *= (const int b)
209 
{ rep *= b;  ; }
210 
inline  void  Int::operator /= (const int b)
211 
{ rep /= b;  ; }
212 
inline  void  Int::operator %= (const int b)
213 
{ rep %= b;  ; }
214 
inline  void  Int::operator |= (const int b)
215 
{ rep |= b;  ; }
216 
inline  void  Int::operator &= (const int b)
217 
{ rep &= b;  ; }
218 
inline  void  Int::operator ^= (const int b)
219 
{ rep ^= b;  ; }
220 
inline  void  Int::operator <<=(const int b)
221 
{ rep <<= b;  ; }
222 
inline  void  Int::operator >>=(const int b)
223 
{ rep >>= b;  ; }
224 
 
225 
 
226 
inline  int& operator  = (int& a,  const Int &   b)     // { dg-error "" }
227 
{ a = b.Int::val(); return a;}
228 
inline  int& operator += (int& a,  const Int &   b)
229 
{ a += b.Int::val(); return a; }
230 
inline  int& operator -= (int& a,  const Int &   b)
231 
{ a -= b.Int::val(); return a;}
232 
inline  int& operator *= (int& a,  const Int &   b)
233 
{ a *= b.Int::val(); return a;}
234 
inline  int& operator /= (int& a,  const Int &   b)
235 
{ a /= b.Int::val(); return a;}
236 
inline  int& operator %= (int& a,  const Int &   b)
237 
{ a %= b.Int::val(); return a;}
238 
inline  int& operator |= (int& a,  const Int &   b)
239 
{ a |= b.Int::val(); return a;}
240 
inline  int& operator &= (int& a,  const Int &   b)
241 
{ a &= b.Int::val(); return a;}
242 
inline  int& operator ^= (int& a,  const Int &   b)
243 
{ a ^= b.Int::val(); return a;}
244 
inline  int& operator <<=(int& a,  const Int &   b)
245 
{ a <<= b.Int::val(); return a;}
246 
inline  int& operator >>=(int& a,  const Int &   b)
247 
{ a >>= b.Int::val(); return a;}
248 
 
249 
 
250 
 
251 
//# 289 "../../../../libg++/etc/benchmarks/Int.h"
252 
 
253 
 
254 
inline  Int  operator -  (const Int &   a) return r(a) // { dg-error "" }
255 
{ r.negate();  } // { dg-error "" }
256 
inline  Int  operator ~  (const Int &   a) return r(a) // { dg-error "" }
257 
{ r.complement();  } // { dg-error "" }
258 
 
259 
inline  Int  operator +  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
260 
{ r += b.Int::val();  } // { dg-error "" }
261 
inline  Int  operator -  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
262 
{ r -= b.Int::val();  } // { dg-error "" }
263 
inline  Int  operator *  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
264 
{ r *= b.Int::val();  } // { dg-error "" }
265 
inline  Int  operator /  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
266 
{ r /= b.Int::val();  } // { dg-error "" }
267 
inline  Int  operator %  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
268 
{ r %= b.Int::val();  } // { dg-error "" }
269 
inline  Int  operator << (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
270 
{ r <<= b.Int::val();  } // { dg-error "" }
271 
inline  Int  operator >> (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
272 
{ r >>= b.Int::val();  } // { dg-error "" }
273 
inline  Int  operator &  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
274 
{ r &= b.Int::val();  } // { dg-error "" }
275 
inline  Int  operator |  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
276 
{ r |= b.Int::val();  } // { dg-error "" }
277 
inline  Int  operator ^  (const Int &   a, const Int &   b) return r(a) // { dg-error "" }
278 
{ r ^= b.Int::val();  } // { dg-error "" }
279 
 
280 
inline  Int  operator +  (const Int &   a, const int b) return r(a) // { dg-error "" }
281 
{ r += b;  } // { dg-error "" }
282 
inline  Int  operator -  (const Int &   a, const int b) return r(a) // { dg-error "" }
283 
{ r -= b;  } // { dg-error "" }
284 
inline  Int  operator *  (const Int &   a, const int b) return r(a) // { dg-error "" }
285 
{ r *= b;  } // { dg-error "" }
286 
inline  Int  operator /  (const Int &   a, const int b) return r(a) // { dg-error "" }
287 
{ r /= b;  } // { dg-error "" }
288 
inline  Int  operator %  (const Int &   a, const int b) return r(a) // { dg-error "" }
289 
{ r %= b;  } // { dg-error "" }
290 
inline  Int  operator << (const Int &   a, const int b) return r(a) // { dg-error "" }
291 
{ r <<= b;  } // { dg-error "" }
292 
inline  Int  operator >> (const Int &   a, const int b) return r(a) // { dg-error "" }
293 
{ r >>= b;  } // { dg-error "" }
294 
inline  Int  operator &  (const Int &   a, const int b) return r(a) // { dg-error "" }
295 
{ r &= b;  } // { dg-error "" }
296 
inline  Int  operator |  (const Int &   a, const int b) return r(a) // { dg-error "" }
297 
{ r |= b;  } // { dg-error "" }
298 
inline  Int  operator ^  (const Int &   a, const int b) return r(a) // { dg-error "" }
299 
{ r ^= b;  } // { dg-error "" }
300 
 
301 
inline  Int  operator +  (const int a, const Int &   b) return r(a) // { dg-error "" }
302 
{ r += b.Int::val();  } // { dg-error "" }
303 
inline  Int  operator -  (const int a, const Int &   b) return r(a) // { dg-error "" }
304 
{ r -= b.Int::val();  } // { dg-error "" }
305 
inline  Int  operator *  (const int a, const Int &   b) return r(a) // { dg-error "" }
306 
{ r *= b.Int::val();  } // { dg-error "" }
307 
inline  Int  operator /  (const int a, const Int &   b) return r(a) // { dg-error "" }
308 
{ r /= b.Int::val();  } // { dg-error "" }
309 
inline  Int  operator %  (const int a, const Int &   b) return r(a) // { dg-error "" }
310 
{ r %= b.Int::val();  } // { dg-error "" }
311 
inline  Int  operator << (const int a, const Int &   b) return r(a) // { dg-error "" }
312 
{ r <<= b.Int::val();  } // { dg-error "" }
313 
inline  Int  operator >> (const int a, const Int &   b) return r(a) // { dg-error "" }
314 
{ r >>= b.Int::val();  } // { dg-error "" }
315 
inline  Int  operator &  (const int a, const Int &   b) return r(a) // { dg-error "" }
316 
{ r &= b.Int::val();  } // { dg-error "" }
317 
inline  Int  operator |  (const int a, const Int &   b) return r(a) // { dg-error "" }
318 
{ r |= b.Int::val();  } // { dg-error "" }
319 
inline  Int  operator ^  (const int a, const Int &   b) return r(a) // { dg-error "" }
320 
{ r ^= b.Int::val();  } // { dg-error "" }
321 
 
322 
 
323 
 
324 
inline  int  operator !  (const Int &   a) { return !a.Int::val(); }
325 
 
326 
inline  int  operator == (const Int &   a, const Int &   b)
327 
{ return a.Int::val() == b.Int::val(); }
328 
inline  int  operator != (const Int &   a, const Int &   b)
329 
{ return a.Int::val() != b.Int::val(); }
330 
inline  int  operator <  (const Int &   a, const Int &   b)
331 
{ return a.Int::val() <  b.Int::val(); }
332 
inline  int  operator <= (const Int &   a, const Int &   b)
333 
{ return a.Int::val() <= b.Int::val(); }
334 
inline  int  operator >  (const Int &   a, const Int &   b)
335 
{ return a.Int::val() >  b.Int::val(); }
336 
inline  int  operator >= (const Int &   a, const Int &   b)
337 
{ return a.Int::val() >= b.Int::val(); }
338 
 
339 
inline  int  operator == (const Int &   a, const int b)
340 
{ return a.Int::val() == b; }
341 
inline  int  operator != (const Int &   a, const int b)
342 
{ return a.Int::val() != b; }
343 
inline  int  operator <  (const Int &   a, const int b)
344 
{ return a.Int::val() <  b; }
345 
inline  int  operator <= (const Int &   a, const int b)
346 
{ return a.Int::val() <= b; }
347 
inline  int  operator >  (const Int &   a, const int b)
348 
{ return a.Int::val() >  b; }
349 
inline  int  operator >= (const Int &   a, const int b)
350 
{ return a.Int::val() >= b; }
351 
 
352 
inline  int  operator == (const int a, const Int &   b)
353 
{ return a == b.Int::val(); }
354 
inline  int  operator != (const int a, const Int &   b)
355 
{ return a != b.Int::val(); }
356 
inline  int  operator <  (const int a, const Int &   b)
357 
{ return a <  b.Int::val(); }
358 
inline  int  operator <= (const int a, const Int &   b)
359 
{ return a <= b.Int::val(); }
360 
inline  int  operator >  (const int a, const Int &   b)
361 
{ return a >  b.Int::val(); }
362 
inline  int  operator >= (const int a, const Int &   b)
363 
{ return a >= b.Int::val(); }
364 
 
365 
 
366 
 
367 
//# 26 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
368 
 
369 
//# 1 "../../../../libg++/etc/benchmarks/Char.h" 1
370 
 
371 
 
372 
 
373 
 
374 
 
375 
 
376 
 
377 
 
378 
 
379 
 
380 
 
381 
 
382 
 
383 
 
384 
 
385 
 
386 
 
387 
 
388 
 
389 
 
390 
 
391 
 
392 
 
393 
 
394 
 
395 
 
396 
 
397 
 
398 
 
399 
 
400 
 
401 
 
402 
 
403 
 
404 
 
405 
 
406 
 
407 
 
408 
 
409 
 
410 
 
411 
 
412 
 
413 
 
414 
 
415 
 
416 
 
417 
 
418 
 
419 
 
420 
 
421 
 
422 
 
423 
 
424 
 
425 
 
426 
 
427 
 
428 
 
429 
 
430 
 
431 
 
432 
 
433 
 
434 
 
435 
 
436 
 
437 
 
438 
 
439 
 
440 
 
441 
 
442 
 
443 
 
444 
 
445 
 
446 
 
447 
class Char
448 
{
449 
protected:
450 
  char          rep;
451 
 
452 
 
453 
 
454 
public:
455 
               Char ();
456 
               Char (const char  b);
457 
               Char (const Char& b);
458 
              ~Char();
459 
 
460 
               operator char() const;
461 
 
462 
  inline virtual  char   val() const;
463 
 
464 
  inline virtual  void  operator  = (const char);
465 
  inline virtual  void  operator  = (const Char&);
466 
 
467 
  inline virtual  void  negate();
468 
  inline virtual  void  complement();
469 
  inline virtual  void  operator ++ ();
470 
  inline virtual  void  operator -- ();
471 
 
472 
  inline virtual  void  operator += (const Char &  );
473 
  inline virtual  void  operator -= (const Char &  );
474 
  inline virtual  void  operator *= (const Char &  );
475 
  inline virtual  void  operator /= (const Char &  );
476 
  inline virtual  void  operator %= (const Char &  );
477 
  inline virtual  void  operator |= (const Char &  );
478 
  inline virtual  void  operator &= (const Char &  );
479 
  inline virtual  void  operator ^= (const Char &  );
480 
  inline virtual  void  operator <<=(const Char &  );
481 
  inline virtual  void  operator >>=(const Char &  );
482 
 
483 
 
484 
  inline virtual  void  operator += (const char);
485 
  inline virtual  void  operator -= (const char);
486 
  inline virtual  void  operator *= (const char);
487 
  inline virtual  void  operator /= (const char);
488 
  inline virtual  void  operator %= (const char);
489 
  inline virtual  void  operator |= (const char);
490 
  inline virtual  void  operator &= (const char);
491 
  inline virtual  void  operator ^= (const char);
492 
  inline virtual  void  operator <<=(const char);
493 
  inline virtual  void  operator >>=(const char);
494 
 
495 
 
496 
};
497 
 
498 
inline  char  Char::val() const { return rep; }
499 
inline       Char::operator char() const { return val(); }
500 
 
501 
inline       Char::Char () :rep(0) {}
502 
inline       Char::Char (const char  b) :rep(b) {}
503 
inline       Char::Char (const Char& b) :rep(b.Char::val()) {}
504 
inline       Char::~Char() {}
505 
 
506 
inline  void  Char::operator  = (const char  b)
507 
{ rep = b;  ; }
508 
inline  void  Char::operator  = (const Char&  b)
509 
{ rep = b.Char::val();  ; }
510 
 
511 
inline  void  Char::complement()
512 
{ rep = ~rep;  ; }
513 
inline  void  Char::negate()
514 
{ rep = -rep;  ; }
515 
inline  void  Char::operator ++ ()
516 
{ ++rep;  ; }
517 
inline  void  Char::operator -- ()
518 
{ --rep;  ; }
519 
 
520 
inline  void  Char::operator += (const Char &   b)
521 
{ rep += b.Char::val();  ; }
522 
inline  void  Char::operator -= (const Char &   b)
523 
{ rep -= b.Char::val();  ; }
524 
inline  void  Char::operator *= (const Char &   b)
525 
{ rep *= b.Char::val();  ; }
526 
inline  void  Char::operator /= (const Char &   b)
527 
{ rep /= b.Char::val();  ; }
528 
inline  void  Char::operator %= (const Char &   b)
529 
{ rep %= b.Char::val();  ; }
530 
inline  void  Char::operator |= (const Char &   b)
531 
{ rep |= b.Char::val();  ; }
532 
inline  void  Char::operator &= (const Char &   b)
533 
{ rep &= b.Char::val();  ; }
534 
inline  void  Char::operator ^= (const Char &   b)
535 
{ rep ^= b.Char::val();  ; }
536 
inline  void  Char::operator <<=(const Char &   b)
537 
{ rep <<= b.Char::val();  ; }
538 
inline  void  Char::operator >>=(const Char &   b)
539 
{ rep >>= b.Char::val();  ; }
540 
 
541 
 
542 
 
543 
inline  void  Char::operator += (const char b)
544 
{ rep += b;  ; }
545 
inline  void  Char::operator -= (const char b)
546 
{ rep -= b;  ; }
547 
inline  void  Char::operator *= (const char b)
548 
{ rep *= b;  ; }
549 
inline  void  Char::operator /= (const char b)
550 
{ rep /= b;  ; }
551 
inline  void  Char::operator %= (const char b)
552 
{ rep %= b;  ; }
553 
inline  void  Char::operator |= (const char b)
554 
{ rep |= b;  ; }
555 
inline  void  Char::operator &= (const char b)
556 
{ rep &= b;  ; }
557 
inline  void  Char::operator ^= (const char b)
558 
{ rep ^= b;  ; }
559 
inline  void  Char::operator <<=(const char b)
560 
{ rep <<= b;  ; }
561 
inline  void  Char::operator >>=(const char b)
562 
{ rep >>= b;  ; }
563 
 
564 
 
565 
inline  char& operator  = (char& a,  const Char &   b)  // { dg-error "" }
566 
{ a = b.Char::val(); return a;}
567 
inline  char& operator += (char& a,  const Char &   b)
568 
{ a += b.Char::val(); return a; }
569 
inline  char& operator -= (char& a,  const Char &   b)
570 
{ a -= b.Char::val(); return a;}
571 
inline  char& operator *= (char& a,  const Char &   b)
572 
{ a *= b.Char::val(); return a;}
573 
inline  char& operator /= (char& a,  const Char &   b)
574 
{ a /= b.Char::val(); return a;}
575 
inline  char& operator %= (char& a,  const Char &   b)
576 
{ a %= b.Char::val(); return a;}
577 
inline  char& operator |= (char& a,  const Char &   b)
578 
{ a |= b.Char::val(); return a;}
579 
inline  char& operator &= (char& a,  const Char &   b)
580 
{ a &= b.Char::val(); return a;}
581 
inline  char& operator ^= (char& a,  const Char &   b)
582 
{ a ^= b.Char::val(); return a;}
583 
inline  char& operator <<=(char& a,  const Char &   b)
584 
{ a <<= b.Char::val(); return a;}
585 
inline  char& operator >>=(char& a,  const Char &   b)
586 
{ a >>= b.Char::val(); return a;}
587 
 
588 
 
589 
 
590 
//# 291 "../../../../libg++/etc/benchmarks/Char.h"
591 
 
592 
 
593 
inline  Char  operator -  (const Char &   a) return r(a) // { dg-error "" }
594 
{ r.negate();  } // { dg-error "" }
595 
inline  Char  operator ~  (const Char &   a) return r(a) // { dg-error "" }
596 
{ r.complement();  } // { dg-error "" }
597 
 
598 
inline  Char  operator +  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
599 
{ r += b.Char::val();  } // { dg-error "" }
600 
inline  Char  operator -  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
601 
{ r -= b.Char::val();  } // { dg-error "" }
602 
inline  Char  operator *  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
603 
{ r *= b.Char::val();  } // { dg-error "" }
604 
inline  Char  operator /  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
605 
{ r /= b.Char::val();  } // { dg-error "" }
606 
inline  Char  operator %  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
607 
{ r %= b.Char::val();  } // { dg-error "" }
608 
inline  Char  operator << (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
609 
{ r <<= b.Char::val();  } // { dg-error "" }
610 
inline  Char  operator >> (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
611 
{ r >>= b.Char::val();  } // { dg-error "" }
612 
inline  Char  operator &  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
613 
{ r &= b.Char::val();  } // { dg-error "" }
614 
inline  Char  operator |  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
615 
{ r |= b.Char::val();  } // { dg-error "" }
616 
inline  Char  operator ^  (const Char &   a, const Char &   b) return r(a) // { dg-error "" }
617 
{ r ^= b.Char::val();  } // { dg-error "" }
618 
 
619 
inline  Char  operator +  (const Char &   a, const char b) return r(a) // { dg-error "" }
620 
{ r += b;  } // { dg-error "" }
621 
inline  Char  operator -  (const Char &   a, const char b) return r(a) // { dg-error "" }
622 
{ r -= b;  } // { dg-error "" }
623 
inline  Char  operator *  (const Char &   a, const char b) return r(a) // { dg-error "" }
624 
{ r *= b;  } // { dg-error "" }
625 
inline  Char  operator /  (const Char &   a, const char b) return r(a) // { dg-error "" }
626 
{ r /= b;  } // { dg-error "" }
627 
inline  Char  operator %  (const Char &   a, const char b) return r(a) // { dg-error "" }
628 
{ r %= b;  } // { dg-error "" }
629 
inline  Char  operator << (const Char &   a, const char b) return r(a) // { dg-error "" }
630 
{ r <<= b;  } // { dg-error "" }
631 
inline  Char  operator >> (const Char &   a, const char b) return r(a) // { dg-error "" }
632 
{ r >>= b;  } // { dg-error "" }
633 
inline  Char  operator &  (const Char &   a, const char b) return r(a) // { dg-error "" }
634 
{ r &= b;  } // { dg-error "" }
635 
inline  Char  operator |  (const Char &   a, const char b) return r(a) // { dg-error "" }
636 
{ r |= b;  } // { dg-error "" }
637 
inline  Char  operator ^  (const Char &   a, const char b) return r(a) // { dg-error "" }
638 
{ r ^= b;  } // { dg-error "" }
639 
 
640 
inline  Char  operator +  (const char a, const Char &   b) return r(a) // { dg-error "" }
641 
{ r += b.Char::val();  } // { dg-error "" }
642 
inline  Char  operator -  (const char a, const Char &   b) return r(a) // { dg-error "" }
643 
{ r -= b.Char::val();  } // { dg-error "" }
644 
inline  Char  operator *  (const char a, const Char &   b) return r(a) // { dg-error "" }
645 
{ r *= b.Char::val();  } // { dg-error "" }
646 
inline  Char  operator /  (const char a, const Char &   b) return r(a) // { dg-error "" }
647 
{ r /= b.Char::val();  } // { dg-error "" }
648 
inline  Char  operator %  (const char a, const Char &   b) return r(a) // { dg-error "" }
649 
{ r %= b.Char::val();  } // { dg-error "" }
650 
inline  Char  operator << (const char a, const Char &   b) return r(a) // { dg-error "" }
651 
{ r <<= b.Char::val();  } // { dg-error "" }
652 
inline  Char  operator >> (const char a, const Char &   b) return r(a) // { dg-error "" }
653 
{ r >>= b.Char::val();  } // { dg-error "" }
654 
inline  Char  operator &  (const char a, const Char &   b) return r(a) // { dg-error "" }
655 
{ r &= b.Char::val();  } // { dg-error "" }
656 
inline  Char  operator |  (const char a, const Char &   b) return r(a) // { dg-error "" }
657 
{ r |= b.Char::val();  } // { dg-error "" }
658 
inline  Char  operator ^  (const char a, const Char &   b) return r(a) // { dg-error "" }
659 
{ r ^= b.Char::val();  } // { dg-error "" }
660 
 
661 
 
662 
 
663 
inline  char  operator !  (const Char &   a) { return !a.Char::val(); }
664 
 
665 
inline  char  operator == (const Char &   a, const Char &   b)
666 
{ return a.Char::val() == b.Char::val(); }
667 
inline  char  operator != (const Char &   a, const Char &   b)
668 
{ return a.Char::val() != b.Char::val(); }
669 
inline  char  operator <  (const Char &   a, const Char &   b)
670 
{ return a.Char::val() <  b.Char::val(); }
671 
inline  char  operator <= (const Char &   a, const Char &   b)
672 
{ return a.Char::val() <= b.Char::val(); }
673 
inline  char  operator >  (const Char &   a, const Char &   b)
674 
{ return a.Char::val() >  b.Char::val(); }
675 
inline  char  operator >= (const Char &   a, const Char &   b)
676 
{ return a.Char::val() >= b.Char::val(); }
677 
 
678 
inline  char  operator == (const Char &   a, const char b)
679 
{ return a.Char::val() == b; }
680 
inline  char  operator != (const Char &   a, const char b)
681 
{ return a.Char::val() != b; }
682 
inline  char  operator <  (const Char &   a, const char b)
683 
{ return a.Char::val() <  b; }
684 
inline  char  operator <= (const Char &   a, const char b)
685 
{ return a.Char::val() <= b; }
686 
inline  char  operator >  (const Char &   a, const char b)
687 
{ return a.Char::val() >  b; }
688 
inline  char  operator >= (const Char &   a, const char b)
689 
{ return a.Char::val() >= b; }
690 
 
691 
inline  char  operator == (const char a, const Char &   b)
692 
{ return a == b.Char::val(); }
693 
inline  char  operator != (const char a, const Char &   b)
694 
{ return a != b.Char::val(); }
695 
inline  char  operator <  (const char a, const Char &   b)
696 
{ return a <  b.Char::val(); }
697 
inline  char  operator <= (const char a, const Char &   b)
698 
{ return a <= b.Char::val(); }
699 
inline  char  operator >  (const char a, const Char &   b)
700 
{ return a >  b.Char::val(); }
701 
inline  char  operator >= (const char a, const Char &   b)
702 
{ return a >= b.Char::val(); }
703 
 
704 
 
705 
 
706 
//# 27 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
707 
 
708 
 
709 
 
710 
 
711 
 
712 
 
713 
 
714 
 
715 
 
716 
 
717 
 
718 
 
719 
 
720 
 
721 
 
722 
 
723 
 
724 
 
725 
 
726 
 
727 
 
728 
 
729 
 
730 
 
731 
 
732 
 
733 
 
734 
 
735 
 
736 
 
737 
 
738 
 
739 
 
740 
 
741 
 
742 
 
743 
 
744 
 
745 
 
746 
 
747 
 
748 
 
749 
 
750 
 
751 
 
752 
 
753 
 
754 
 
755 
 
756 
 
757 
 
758 
 
759 
 
760 
 
761 
 
762 
 
763 
 
764 
 
765 
 
766 
 
767 
 
768 
 
769 
 
770 
 
771 
 
772 
 
773 
 
774 
 
775 
 
776 
 
777 
 
778 
 
779 
 
780 
 
781 
 
782 
 
783 
 
784 
 
785 
 
786 
 
787 
 
788 
 
789 
 
790 
 
791 
 
792 
 
793 
 
794 
 
795 
 
796 
 
797 
 
798 
 
799 
 
800 
 
801 
 
802 
 
803 
 
804 
 
805 
 
806 
 
807 
 
808 
 
809 
 
810 
 
811 
 
812 
 
813 
 
814 
 
815 
 
816 
 
817 
 
818 
 
819 
 
820 
 
821 
 
822 
 
823 
 
824 
 
825 
 
826 
 
827 
 
828 
 
829 
 
830 
 
831 
 
832 
 
833 
 
834 
 
835 
 
836 
 
837 
 
838 
 
839 
 
840 
 
841 
 
842 
 
843 
 
844 
 
845 
 
846 
 
847 
 
848 
 
849 
 
850 
 
851 
 
852 
 
853 
 
854 
 
855 
 
856 
 
857 
 
858 
 
859 
 
860 
 
861 
 
862 
 
863 
 
864 
 
865 
 
866 
 
867 
 
868 
 
869 
 
870 
 
871 
 
872 
 
873 
 
874 
 
875 
 
876 
 
877 
 
878 
 
879 
 
880 
 
881 
 
882 
 
883 
 
884 
 
885 
 
886 
 
887 
 
888 
 
889 
 
890 
 
891 
 
892 
 
893 
 
894 
 
895 
 
896 
 
897 
 
898 
 
899 
 
900 
 
901 
 
902 
 
903 
 
904 
 
905 
 
906 
 
907 
 
908 
 
909 
 
910 
 
911 
 
912 
 
913 
 
914 
 
915 
 
916 
 
917 
 
918 
 
919 
 
920 
 
921 
 
922 
 
923 
 
924 
 
925 
 
926 
 
927 
 
928 
 
929 
 
930 
 
931 
 
932 
 
933 
 
934 
 
935 
 
936 
 
937 
 
938 
 
939 
 
940 
 
941 
 
942 
 
943 
 
944 
 
945 
 
946 
 
947 
 
948 
 
949 
 
950 
 
951 
 
952 
 
953 
 
954 
 
955 
 
956 
 
957 
 
958 
 
959 
 
960 
 
961 
 
962 
 
963 
 
964 
 
965 
 
966 
 
967 
 
968 
 
969 
 
970 
 
971 
 
972 
 
973 
 
974 
 
975 
 
976 
 
977 
 
978 
 
979 
 
980 
 
981 
 
982 
 
983 
 
984 
 
985 
 
986 
 
987 
 
988 
 
989 
 
990 
//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
991 
 
992 
 
993 
//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
994 
 
995 
extern "C" {
996 
//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
997 
 
998 
 
999 
 
1000 
 
1001 
 
1002 
 
1003 
 
1004 
 
1005 
 
1006 
 
1007 
 
1008 
 
1009 
 
1010 
 
1011 
 
1012 
 
1013 
 
1014 
 
1015 
 
1016 
 
1017 
 
1018 
 
1019 
 
1020 
 
1021 
 
1022 
 
1023 
 
1024 
 
1025 
 
1026 
 
1027 
typedef int ptrdiff_t;
1028 
 
1029 
 
1030 
 
1031 
 
1032 
 
1033 
 
1034 
 
1035 
 
1036 
 
1037 
 
1038 
 
1039 
 
1040 
 
1041 
 
1042 
 
1043 
 
1044 
 
1045 
 
1046 
 
1047 
 
1048 
 
1049 
typedef int size_t;
1050 
 
1051 
 
1052 
 
1053 
 
1054 
 
1055 
 
1056 
 
1057 
 
1058 
 
1059 
 
1060 
 
1061 
 
1062 
 
1063 
 
1064 
 
1065 
 
1066 
 
1067 
 
1068 
 
1069 
 
1070 
 
1071 
 
1072 
 
1073 
 
1074 
 
1075 
 
1076 
 
1077 
 
1078 
 
1079 
 
1080 
 
1081 
 
1082 
 
1083 
 
1084 
 
1085 
 
1086 
 
1087 
 
1088 
 
1089 
 
1090 
//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
1091 
 
1092 
}
1093 
//# 73 "/giga/hgs/lib/g++-include/stddef.h"
1094 
 
1095 
//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
1096 
 
1097 
 
1098 
 
1099 
 
1100 
extern "C"
1101 
{
1102 
 
1103 
 
1104 
 
1105 
 
1106 
 
1107 
 
1108 
 
1109 
 
1110 
 
1111 
 
1112 
 
1113 
 
1114 
 
1115 
 
1116 
 
1117 
 
1118 
 
1119 
 
1120 
 
1121 
 
1122 
 
1123 
 
1124 
 
1125 
 
1126 
 
1127 
 
1128 
//# 1 "/usr/include/sys/types.h" 1
1129 
 
1130 
 
1131 
 
1132 
 
1133 
 
1134 
 
1135 
 
1136 
 
1137 
 
1138 
 
1139 
 
1140 
 
1141 
 
1142 
 
1143 
 
1144 
//# 1 "/usr/include/sys/stdtypes.h" 1
1145 
 
1146 
 
1147 
 
1148 
 
1149 
 
1150 
 
1151 
 
1152 
 
1153 
 
1154 
 
1155 
 
1156 
 
1157 
 
1158 
typedef int             sigset_t;
1159 
 
1160 
typedef unsigned int    speed_t;
1161 
typedef unsigned long   tcflag_t;
1162 
typedef unsigned char   cc_t;
1163 
typedef int             pid_t;
1164 
 
1165 
typedef unsigned short  mode_t;
1166 
typedef short           nlink_t;
1167 
 
1168 
typedef long            clock_t;
1169 
typedef long            time_t;
1170 
 
1171 
typedef int             size_t;
1172 
typedef int             ptrdiff_t;
1173 
 
1174 
 
1175 
//# 16 "/usr/include/sys/types.h" 2
1176 
 
1177 
 
1178 
 
1179 
//# 1 "/usr/include/sys/sysmacros.h" 1
1180 
 
1181 
 
1182 
 
1183 
 
1184 
 
1185 
 
1186 
 
1187 
 
1188 
 
1189 
 
1190 
 
1191 
 
1192 
 
1193 
 
1194 
 
1195 
 
1196 
 
1197 
 
1198 
 
1199 
//# 19 "/usr/include/sys/types.h" 2
1200 
 
1201 
 
1202 
 
1203 
 
1204 
 
1205 
typedef unsigned char   u_char;
1206 
typedef unsigned short  u_short;
1207 
typedef unsigned int    u_int;
1208 
typedef unsigned long   u_long;
1209 
typedef unsigned short  ushort;
1210 
typedef unsigned int    uint;
1211 
 
1212 
 
1213 
 
1214 
 
1215 
 
1216 
 
1217 
 
1218 
 
1219 
 
1220 
 
1221 
 
1222 
 
1223 
 
1224 
 
1225 
 
1226 
typedef struct  _physadr_t { int r[1]; } *physadr_t;
1227 
typedef struct label_t {
1228 
        int     val[2];
1229 
} label_t;
1230 
 
1231 
 
1232 
 
1233 
 
1234 
 
1235 
 
1236 
 
1237 
typedef struct  _quad_t { long val[2]; } quad_t;
1238 
typedef long    daddr_t;
1239 
typedef char *  caddr_t;
1240 
typedef unsigned long   ino_t;
1241 
typedef short   dev_t;
1242 
typedef long    off_t;
1243 
typedef unsigned short  uid_t;
1244 
typedef unsigned short  gid_t;
1245 
typedef long    key_t;
1246 
typedef char *  addr_t;
1247 
 
1248 
 
1249 
 
1250 
 
1251 
 
1252 
 
1253 
 
1254 
 
1255 
 
1256 
 
1257 
 
1258 
 
1259 
 
1260 
 
1261 
typedef long    fd_mask;
1262 
 
1263 
 
1264 
 
1265 
 
1266 
 
1267 
 
1268 
 
1269 
 
1270 
 
1271 
typedef struct fd_set {
1272 
        fd_mask fds_bits[(((256 )+(( (sizeof (fd_mask) * 8              )       )-1))/( (sizeof (fd_mask) * 8           )       )) ];
1273 
} fd_set;
1274 
 
1275 
 
1276 
 
1277 
 
1278 
 
1279 
 
1280 
 
1281 
//# 113 "/usr/include/sys/types.h"
1282 
 
1283 
 
1284 
 
1285 
//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
1286 
 
1287 
 
1288 
 
1289 
 
1290 
 
1291 
 
1292 
 
1293 
 
1294 
 
1295 
 
1296 
 
1297 
 
1298 
 
1299 
 
1300 
 
1301 
 
1302 
 
1303 
 
1304 
 
1305 
 
1306 
 
1307 
 
1308 
 
1309 
 
1310 
 
1311 
 
1312 
 
1313 
 
1314 
 
1315 
 
1316 
 
1317 
 
1318 
 
1319 
}
1320 
 
1321 
 
1322 
 
1323 
 
1324 
//# 310 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
1325 
 
1326 
//# 1 "/giga/hgs/lib/g++-include/sys/times.h" 1
1327 
//# 1 "/giga/hgs/lib/g++-include/time.h" 1
1328 
 
1329 
 
1330 
 
1331 
 
1332 
 
1333 
//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
1334 
 
1335 
extern "C" {
1336 
//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
1337 
//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
1338 
 
1339 
//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
1340 
 
1341 
}
1342 
//# 73 "/giga/hgs/lib/g++-include/stddef.h"
1343 
 
1344 
//# 6 "/giga/hgs/lib/g++-include/time.h" 2
1345 
 
1346 
//# 1 "/giga/hgs/lib/g++-include/stdio.h" 1
1347 
 
1348 
 
1349 
 
1350 
 
1351 
 
1352 
 
1353 
 
1354 
 
1355 
 
1356 
 
1357 
 
1358 
 
1359 
 
1360 
 
1361 
 
1362 
 
1363 
 
1364 
 
1365 
 
1366 
 
1367 
 
1368 
 
1369 
 
1370 
 
1371 
 
1372 
 
1373 
 
1374 
 
1375 
 
1376 
 
1377 
 
1378 
 
1379 
 
1380 
 
1381 
 
1382 
 
1383 
 
1384 
 
1385 
 
1386 
 
1387 
 
1388 
 
1389 
 
1390 
 
1391 
 
1392 
 
1393 
 
1394 
 
1395 
//#pragma interface
1396 
 
1397 
 
1398 
 
1399 
 
1400 
 
1401 
 
1402 
 
1403 
 
1404 
 
1405 
 
1406 
 
1407 
 
1408 
 
1409 
 
1410 
 
1411 
 
1412 
 
1413 
 
1414 
 
1415 
//# 80 "/giga/hgs/lib/g++-include/stdio.h"
1416 
 
1417 
 
1418 
 
1419 
//# 117 "/giga/hgs/lib/g++-include/stdio.h"
1420 
 
1421 
 
1422 
 
1423 
 
1424 
 
1425 
//# 153 "/giga/hgs/lib/g++-include/stdio.h"
1426 
 
1427 
 
1428 
 
1429 
extern "C" {
1430 
 
1431 
 
1432 
 
1433 
 
1434 
 
1435 
 
1436 
 
1437 
 
1438 
 
1439 
 
1440 
 
1441 
 
1442 
 
1443 
 
1444 
 
1445 
 
1446 
 
1447 
 
1448 
 
1449 
 
1450 
 
1451 
 
1452 
 
1453 
 
1454 
 
1455 
 
1456 
 
1457 
 
1458 
//# 1 "/usr/include/stdio.h" 1
1459 
 
1460 
 
1461 
 
1462 
 
1463 
 
1464 
extern  struct  _iobuf {
1465 
        int     _cnt;
1466 
        unsigned char *_ptr;
1467 
        unsigned char *_base;
1468 
        int     _bufsiz;
1469 
        short   _flag;
1470 
        char    _file;
1471 
} _iob[];
1472 
 
1473 
 
1474 
 
1475 
 
1476 
 
1477 
 
1478 
 
1479 
 
1480 
 
1481 
 
1482 
 
1483 
 
1484 
 
1485 
 
1486 
 
1487 
 
1488 
 
1489 
 
1490 
 
1491 
 
1492 
 
1493 
 
1494 
 
1495 
 
1496 
 
1497 
 
1498 
 
1499 
 
1500 
 
1501 
 
1502 
 
1503 
 
1504 
 
1505 
 
1506 
 
1507 
 
1508 
 
1509 
 
1510 
 
1511 
extern struct _iobuf    *c_proto_fopen ();
1512 
extern struct _iobuf    *c_proto_fdopen ();
1513 
extern struct _iobuf    *c_proto_freopen ();
1514 
extern struct _iobuf    *c_proto_popen ();
1515 
extern struct _iobuf    *tmpfile();
1516 
extern long     ftell(_iobuf *);
1517 
extern char     *fgets(char *, int, _iobuf *);
1518 
extern char     *gets(char *);
1519 
extern char     *c_proto_sprintf ();
1520 
extern char     *ctermid();
1521 
extern char     *cuserid();
1522 
extern char     *c_proto_tempnam ();
1523 
extern char     *tmpnam();
1524 
 
1525 
 
1526 
 
1527 
 
1528 
 
1529 
 
1530 
//# 185 "/giga/hgs/lib/g++-include/stdio.h" 2
1531 
 
1532 
 
1533 
 
1534 
 
1535 
 
1536 
 
1537 
 
1538 
 
1539 
 
1540 
 
1541 
 
1542 
 
1543 
 
1544 
 
1545 
 
1546 
 
1547 
 
1548 
 
1549 
 
1550 
 
1551 
 
1552 
 
1553 
 
1554 
 
1555 
 
1556 
 
1557 
 
1558 
 
1559 
 
1560 
 
1561 
 
1562 
}
1563 
//# 417 "/giga/hgs/lib/g++-include/stdio.h"
1564 
 
1565 
 
1566 
 
1567 
 
1568 
 
1569 
 
1570 
extern "C" {
1571 
 
1572 
 
1573 
 
1574 
 
1575 
 
1576 
 
1577 
 
1578 
int    _doprnt(const char*, void*, struct _iobuf *);
1579 
int    _doscan(struct _iobuf *, const char*, ...);
1580 
int    _filbuf(struct _iobuf *);
1581 
int    _flsbuf(unsigned, struct _iobuf *);
1582 
 
1583 
int    fclose(struct _iobuf *);
1584 
struct _iobuf *  fdopen(int, const char*);
1585 
int    fflush(struct _iobuf *);
1586 
int    fgetc(struct _iobuf *);
1587 
char*  fgets(char*, int, struct _iobuf  *);
1588 
struct _iobuf *  fopen(const char*, const char*);
1589 
int    fprintf(struct _iobuf *, const char* ...);
1590 
int    fputc(int, struct _iobuf *);
1591 
int    fputs(const char*, struct _iobuf *);
1592 
int fread(void*, int, int, struct _iobuf *);
1593 
 
1594 
 
1595 
 
1596 
struct _iobuf *  freopen(const char*, const char*, struct _iobuf *);
1597 
 
1598 
int    fscanf(struct _iobuf *, const char* ...);
1599 
int    fseek(struct _iobuf *, long, int);
1600 
long   ftell(struct _iobuf  *);
1601 
int fwrite(const void*, int, int, struct _iobuf *);
1602 
char*  gets(char*);
1603 
int    getw(struct _iobuf *);
1604 
int    pclose(struct _iobuf *);
1605 
void   perror(const char*);
1606 
struct _iobuf *  popen(const char*, const char*);
1607 
int    printf(const char* ...);
1608 
int    puts(const char*);
1609 
int    putw(int, struct _iobuf *);
1610 
int    rewind(struct _iobuf *);
1611 
int    scanf(const char* ...);
1612 
int    setbuf(struct _iobuf *, char*);
1613 
int    setbuffer(struct _iobuf *, char*, int);
1614 
int    setlinebuf(struct _iobuf *);
1615 
int    setvbuf(struct _iobuf *, char*, int, int);
1616 
int    sscanf(char*, const char* ...);
1617 
struct _iobuf *  tmpfile();
1618 
int    ungetc(int, struct _iobuf *);
1619 
int    vfprintf(struct _iobuf *, const char*, ...);
1620 
 
1621 
 
1622 
 
1623 
 
1624 
int    vprintf(const char*, ... );
1625 
 
1626 
 
1627 
 
1628 
 
1629 
 
1630 
int  sprintf(char*, const char*, ...);
1631 
char*  vsprintf(char*, const char*, ...);
1632 
 
1633 
 
1634 
}
1635 
 
1636 
 
1637 
 
1638 
 
1639 
 
1640 
 
1641 
 
1642 
 
1643 
 
1644 
 
1645 
 
1646 
 
1647 
 
1648 
 
1649 
 
1650 
 
1651 
 
1652 
//# 7 "/giga/hgs/lib/g++-include/time.h" 2
1653 
 
1654 
 
1655 
//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
1656 
 
1657 
 
1658 
//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
1659 
 
1660 
extern "C" {
1661 
//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
1662 
//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
1663 
 
1664 
//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
1665 
 
1666 
}
1667 
//# 73 "/giga/hgs/lib/g++-include/stddef.h"
1668 
 
1669 
//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
1670 
 
1671 
 
1672 
 
1673 
 
1674 
extern "C"
1675 
{
1676 
 
1677 
 
1678 
 
1679 
 
1680 
 
1681 
 
1682 
 
1683 
 
1684 
 
1685 
 
1686 
 
1687 
 
1688 
 
1689 
 
1690 
 
1691 
 
1692 
 
1693 
 
1694 
 
1695 
 
1696 
 
1697 
 
1698 
 
1699 
 
1700 
 
1701 
 
1702 
//# 1 "/usr/include/sys/types.h" 1
1703 
 
1704 
 
1705 
 
1706 
 
1707 
 
1708 
 
1709 
 
1710 
 
1711 
//# 115 "/usr/include/sys/types.h"
1712 
 
1713 
//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
1714 
 
1715 
 
1716 
 
1717 
 
1718 
 
1719 
 
1720 
 
1721 
 
1722 
 
1723 
 
1724 
 
1725 
 
1726 
 
1727 
 
1728 
 
1729 
 
1730 
 
1731 
 
1732 
 
1733 
 
1734 
 
1735 
 
1736 
 
1737 
 
1738 
 
1739 
 
1740 
 
1741 
 
1742 
 
1743 
 
1744 
 
1745 
 
1746 
 
1747 
}
1748 
 
1749 
 
1750 
 
1751 
 
1752 
//# 9 "/giga/hgs/lib/g++-include/time.h" 2
1753 
 
1754 
 
1755 
extern "C" {
1756 
 
1757 
 
1758 
 
1759 
 
1760 
 
1761 
 
1762 
 
1763 
 
1764 
 
1765 
 
1766 
 
1767 
 
1768 
 
1769 
 
1770 
 
1771 
 
1772 
 
1773 
//# 42 "/giga/hgs/lib/g++-include/time.h"
1774 
 
1775 
 
1776 
 
1777 
 
1778 
 
1779 
 
1780 
 
1781 
//# 1 "/usr/include/time.h" 1
1782 
 
1783 
 
1784 
 
1785 
 
1786 
 
1787 
//# 1 "/usr/include/sys/stdtypes.h" 1
1788 
 
1789 
 
1790 
 
1791 
 
1792 
 
1793 
 
1794 
 
1795 
 
1796 
 
1797 
 
1798 
//# 32 "/usr/include/sys/stdtypes.h"
1799 
 
1800 
//# 6 "/usr/include/time.h" 2
1801 
 
1802 
 
1803 
 
1804 
 
1805 
struct  tm {
1806 
        int     tm_sec;
1807 
        int     tm_min;
1808 
        int     tm_hour;
1809 
        int     tm_mday;
1810 
        int     tm_mon;
1811 
        int     tm_year;
1812 
        int     tm_wday;
1813 
        int     tm_yday;
1814 
        int     tm_isdst;
1815 
        char    *tm_zone;
1816 
        long    tm_gmtoff;
1817 
};
1818 
 
1819 
extern  struct tm *c_proto_gmtime (), *c_proto_localtime ();
1820 
extern  char *c_proto_asctime (), *c_proto_ctime ();
1821 
extern  void c_proto_tzset (), c_proto_tzsetwall ();
1822 
extern  int dysize(int);
1823 
extern  time_t timelocal(), timegm();
1824 
 
1825 
 
1826 
//# 49 "/giga/hgs/lib/g++-include/time.h" 2
1827 
 
1828 
 
1829 
//# 1 "/usr/include/sys/times.h" 1
1830 
 
1831 
 
1832 
 
1833 
 
1834 
 
1835 
 
1836 
 
1837 
 
1838 
 
1839 
//# 1 "/giga/hgs/lib/g++-include/sys/types.h" 1
1840 
 
1841 
 
1842 
//# 1 "/giga/hgs/lib/g++-include/stddef.h" 1
1843 
 
1844 
extern "C" {
1845 
//# 1 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h" 1
1846 
//# 94 "/giga/hgs/lib/gcc/sun4/cygnus-1.96/include/stddef.h"
1847 
 
1848 
//# 3 "/giga/hgs/lib/g++-include/stddef.h" 2
1849 
 
1850 
}
1851 
//# 73 "/giga/hgs/lib/g++-include/stddef.h"
1852 
 
1853 
//# 3 "/giga/hgs/lib/g++-include/sys/types.h" 2
1854 
 
1855 
 
1856 
 
1857 
 
1858 
extern "C"
1859 
{
1860 
 
1861 
 
1862 
 
1863 
 
1864 
 
1865 
 
1866 
 
1867 
 
1868 
 
1869 
 
1870 
 
1871 
 
1872 
 
1873 
 
1874 
 
1875 
 
1876 
 
1877 
 
1878 
 
1879 
 
1880 
 
1881 
 
1882 
 
1883 
 
1884 
 
1885 
 
1886 
//# 1 "/usr/include/sys/types.h" 1
1887 
 
1888 
 
1889 
 
1890 
 
1891 
 
1892 
 
1893 
 
1894 
 
1895 
//# 115 "/usr/include/sys/types.h"
1896 
 
1897 
//# 35 "/giga/hgs/lib/g++-include/sys/types.h" 2
1898 
 
1899 
 
1900 
 
1901 
 
1902 
 
1903 
 
1904 
 
1905 
 
1906 
 
1907 
 
1908 
 
1909 
 
1910 
 
1911 
 
1912 
 
1913 
 
1914 
 
1915 
 
1916 
 
1917 
 
1918 
 
1919 
 
1920 
 
1921 
 
1922 
 
1923 
 
1924 
 
1925 
 
1926 
 
1927 
 
1928 
 
1929 
 
1930 
 
1931 
}
1932 
 
1933 
 
1934 
 
1935 
 
1936 
//# 10 "/usr/include/sys/times.h" 2
1937 
 
1938 
 
1939 
struct tms {
1940 
        clock_t tms_utime;
1941 
        clock_t tms_stime;
1942 
        clock_t tms_cutime;
1943 
        clock_t tms_cstime;
1944 
};
1945 
 
1946 
 
1947 
clock_t times(tms * );
1948 
 
1949 
 
1950 
 
1951 
//# 51 "/giga/hgs/lib/g++-include/time.h" 2
1952 
 
1953 
 
1954 
 
1955 
 
1956 
 
1957 
 
1958 
 
1959 
 
1960 
 
1961 
 
1962 
 
1963 
 
1964 
 
1965 
 
1966 
 
1967 
 
1968 
 
1969 
 
1970 
 
1971 
 
1972 
 
1973 
extern struct tm* localtime(long*);
1974 
extern struct tm* gmtime(long*);
1975 
extern char* ctime(long*);
1976 
extern char* asctime(struct tm*);
1977 
extern void tzset();
1978 
extern void tzsetwall();
1979 
 
1980 
 
1981 
 
1982 
 
1983 
 
1984 
 
1985 
extern long times(struct tms*);
1986 
 
1987 
 
1988 
//# 97 "/giga/hgs/lib/g++-include/time.h"
1989 
 
1990 
extern char* timezone(int, int);
1991 
extern int getitimer(int, struct itimerval*);
1992 
extern int setitimer(int, struct itimerval*, struct itimerval*);
1993 
extern int gettimeofday(struct timeval*, struct timezone*);
1994 
extern int settimeofday(struct timeval*, struct timezone*);
1995 
extern int stime(long*);
1996 
int       dysize(int);
1997 
 
1998 
 
1999 
 
2000 
 
2001 
 
2002 
 
2003 
 
2004 
 
2005 
long      clock(void);
2006 
 
2007 
long      time(long*);
2008 
unsigned  ualarm(unsigned, unsigned);
2009 
unsigned  usleep(unsigned);
2010 
int       profil(char*, int, int, int);
2011 
 
2012 
}
2013 
 
2014 
 
2015 
 
2016 
//# 1 "/giga/hgs/lib/g++-include/sys/times.h" 2
2017 
 
2018 
//# 311 "../../../../libg++/etc/benchmarks/dhrystone.cc" 2
2019 
 
2020 
 
2021 
 
2022 
 
2023 
 
2024 
 
2025 
 
2026 
 
2027 
 
2028 
 
2029 
 
2030 
 
2031 
 
2032 
 
2033 
 
2034 
 
2035 
 
2036 
 
2037 
 
2038 
 
2039 
 
2040 
 
2041 
 
2042 
 
2043 
typedef enum    {Ident1, Ident2, Ident3, Ident4, Ident5} Enumeration;
2044 
 
2045 
 
2046 
 
2047 
 
2048 
typedef Int     OneToThirty;
2049 
typedef Int     OneToFifty;
2050 
typedef Char    CapitalLetter;
2051 
typedef Char    String30[31];
2052 
typedef Int     Array1Dim[51];
2053 
typedef Int     Array2Dim[51][51];
2054 
 
2055 
struct  Record
2056 
{
2057 
        struct Record           *PtrComp;
2058 
        Enumeration             Discr;
2059 
        Enumeration             EnumComp;
2060 
        OneToFifty              IntComp;
2061 
        String30                StringComp;
2062 
};
2063 
 
2064 
typedef struct Record   RecordType;
2065 
typedef RecordType *    RecordPtr;
2066 
typedef int             boolean;
2067 
 
2068 
 
2069 
 
2070 
 
2071 
 
2072 
 
2073 
 
2074 
 
2075 
 
2076 
 
2077 
 
2078 
extern "C" {
2079 
extern int printf(const char* ...);
2080 
extern void exit(int);
2081 
}
2082 
 
2083 
void Proc0();
2084 
void Proc1(RecordPtr PtrParIn);
2085 
void Proc2(OneToFifty   *IntParIO);
2086 
void Proc3(RecordPtr    *PtrParOut);
2087 
void Proc4();
2088 
void Proc5();
2089 
boolean Func3(Enumeration       EnumParIn);
2090 
void Proc6(  Enumeration        EnumParIn,   Enumeration        *EnumParOut);
2091 
void Proc7(OneToFifty IntParI1, OneToFifty IntParI2, OneToFifty *IntParOut);
2092 
void Proc8(Array1Dim    Array1Par,
2093 
      Array2Dim Array2Par,
2094 
      OneToFifty IntParI1,
2095 
      OneToFifty IntParI2);
2096 
Enumeration Func1(CapitalLetter CharPar1, CapitalLetter CharPar2);
2097 
boolean Func2(String30  StrParI1, String30      StrParI2);
2098 
boolean Func3(Enumeration       EnumParIn);
2099 
 
2100 
void mystrcpy(String30 s, const char* t)
2101 
{
2102 
  for (; *t != '\0'; ++s, ++t) *s = *t;
2103 
  *s = '\0';
2104 
}
2105 
 
2106 
char mystrcmp(String30 s, String30 t)
2107 
{
2108 
  for (; *s == *t; ++s, ++t) if (*s == '\0') return 0;
2109 
  return char(*s - *t);
2110 
}
2111 
 
2112 
 
2113 
 
2114 
main()
2115 
{
2116 
        Proc0();
2117 
        exit(0);
2118 
}
2119 
 
2120 
 
2121 
 
2122 
 
2123 
Int             IntGlob;
2124 
boolean         BoolGlob;
2125 
char            Char1Glob;
2126 
char            Char2Glob;
2127 
Array1Dim       Array1Glob;
2128 
Array2Dim       Array2Glob;
2129 
RecordPtr       PtrGlb;
2130 
RecordPtr       PtrGlbNext;
2131 
 
2132 
void Proc0()
2133 
{
2134 
        OneToFifty              IntLoc1;
2135 
          OneToFifty            IntLoc2;
2136 
        OneToFifty              IntLoc3;
2137 
          char          CharLoc;
2138 
          char          CharIndex;
2139 
        Enumeration             EnumLoc;
2140 
        String30                String1Loc;
2141 
        String30                String2Loc;
2142 
 
2143 
//# 445 "../../../../libg++/etc/benchmarks/dhrystone.cc"
2144 
 
2145 
 
2146 
        time_t                  starttime;
2147 
        time_t                  benchtime;
2148 
        time_t                  nulltime;
2149 
        struct tms              Tms;
2150 
        register unsigned int   i;
2151 
 
2152 
        times(&Tms); starttime = Tms.tms_utime;
2153 
        for (i = 0; i < 500000          ; ++i);
2154 
        times(&Tms);
2155 
        nulltime = Tms.tms_utime - starttime;
2156 
 
2157 
 
2158 
        PtrGlbNext = new Record;
2159 
        PtrGlb = new Record;
2160 
        PtrGlb->PtrComp = PtrGlbNext;
2161 
        PtrGlb->Discr = Ident1;
2162 
        PtrGlb->EnumComp = Ident3;
2163 
        PtrGlb->IntComp = 40;
2164 
        mystrcpy(PtrGlb->StringComp, "DHRYSTONE PROGRAM, SOME STRING");
2165 
        mystrcpy(String1Loc, "JUST INITIALIZED TO SOME JUNK.");
2166 
 
2167 
 
2168 
 
2169 
 
2170 
 
2171 
 
2172 
 
2173 
 
2174 
        times(&Tms); starttime = Tms.tms_utime;
2175 
 
2176 
        for (i = 0; i < 500000          ; ++i)
2177 
        {
2178 
 
2179 
                Proc5();
2180 
                Proc4();
2181 
                IntLoc1 = 2;
2182 
                IntLoc2 = 3;
2183 
                mystrcpy(String2Loc, "DHRYSTONE PROGRAM, 2'ND STRING");
2184 
                EnumLoc = Ident2;
2185 
                BoolGlob = ! Func2(String1Loc, String2Loc);
2186 
                while (IntLoc1 < IntLoc2)
2187 
                {
2188 
                        IntLoc3 = 5 * IntLoc1 - IntLoc2;
2189 
                        Proc7(IntLoc1, IntLoc2, &IntLoc3);
2190 
                        ++IntLoc1;
2191 
                }
2192 
                Proc8(Array1Glob, Array2Glob, IntLoc1, IntLoc3);
2193 
                Proc1(PtrGlb);
2194 
                for (CharIndex = 'A'; CharIndex <= Char2Glob; ++CharIndex)
2195 
                        if (EnumLoc == Func1(CharIndex, 'C'))
2196 
                                Proc6(Ident1, &EnumLoc);
2197 
                IntLoc3 = IntLoc2 * IntLoc1;
2198 
                IntLoc2 = IntLoc3 / IntLoc1;
2199 
                IntLoc2 = 7 * (IntLoc3 - IntLoc2) - IntLoc1;
2200 
                Proc2(&IntLoc1);
2201 
        }
2202 
 
2203 
 
2204 
 
2205 
 
2206 
 
2207 
 
2208 
 
2209 
 
2210 
 
2211 
 
2212 
 
2213 
 
2214 
 
2215 
        times(&Tms);
2216 
        benchtime = Tms.tms_utime - starttime - nulltime;
2217 
        printf("Dhrystone time for %ld passes = %ld\n",
2218 
                (long) 500000           , benchtime/60          );
2219 
        printf("This machine benchmarks at %ld dhrystones/second\n",
2220 
                ((long) 500000          ) * 60           / benchtime);
2221 
 
2222 
 
2223 
}
2224 
 
2225 
void Proc1(RecordPtr PtrParIn)
2226 
{
2227 
 
2228 
 
2229 
        (*(PtrParIn->PtrComp))  =  *PtrGlb ;
2230 
        PtrParIn->IntComp = 5;
2231 
        (*(PtrParIn->PtrComp)) .IntComp = PtrParIn->IntComp;
2232 
        (*(PtrParIn->PtrComp)) .PtrComp = PtrParIn->PtrComp;
2233 
 
2234 
        Proc3(&((*(PtrParIn->PtrComp)) .PtrComp));
2235 
        if ((*(PtrParIn->PtrComp)) .Discr == Ident1)
2236 
        {
2237 
                (*(PtrParIn->PtrComp)) .IntComp = 6;
2238 
                Proc6(PtrParIn->EnumComp, &(*(PtrParIn->PtrComp)) .EnumComp);
2239 
                (*(PtrParIn->PtrComp)) .PtrComp = PtrGlb->PtrComp;
2240 
                Proc7((*(PtrParIn->PtrComp)) .IntComp, 10, &(*(PtrParIn->PtrComp)) .IntComp);
2241 
        }
2242 
        else
2243 
                *PtrParIn =  (*(PtrParIn->PtrComp))  ;
2244 
 
2245 
 
2246 
}
2247 
 
2248 
void Proc2(OneToFifty   *IntParIO)
2249 
{
2250 
          OneToFifty            IntLoc;
2251 
          Enumeration           EnumLoc;
2252 
 
2253 
        IntLoc = *IntParIO + 10;
2254 
        for(;;)
2255 
        {
2256 
                if (Char1Glob == 'A')
2257 
                {
2258 
                        --IntLoc;
2259 
                        *IntParIO = IntLoc - IntGlob;
2260 
                        EnumLoc = Ident1;
2261 
                }
2262 
                if (EnumLoc == Ident1)
2263 
                        break;
2264 
        }
2265 
}
2266 
 
2267 
void Proc3(RecordPtr    *PtrParOut)
2268 
{
2269 
        if (PtrGlb != 0 )
2270 
                *PtrParOut = PtrGlb->PtrComp;
2271 
        else
2272 
                IntGlob = 100;
2273 
        Proc7(10, IntGlob, &PtrGlb->IntComp);
2274 
}
2275 
 
2276 
void Proc4()
2277 
{
2278 
          boolean       BoolLoc;
2279 
 
2280 
        BoolLoc = Char1Glob == 'A';
2281 
        BoolLoc |= BoolGlob;
2282 
        Char2Glob = 'B';
2283 
}
2284 
 
2285 
void Proc5()
2286 
{
2287 
        Char1Glob = 'A';
2288 
        BoolGlob =      0 ;
2289 
}
2290 
 
2291 
 
2292 
 
2293 
 
2294 
void Proc6(  Enumeration        EnumParIn,   Enumeration        *EnumParOut)
2295 
{
2296 
        *EnumParOut = EnumParIn;
2297 
        if (! Func3(EnumParIn) )
2298 
                *EnumParOut = Ident4;
2299 
        switch (EnumParIn)
2300 
        {
2301 
        case Ident1:    *EnumParOut = Ident1; break;
2302 
        case Ident2:    if (IntGlob > 100) *EnumParOut = Ident1;
2303 
                        else *EnumParOut = Ident4;
2304 
                        break;
2305 
        case Ident3:    *EnumParOut = Ident2; break;
2306 
        case Ident4:    break;
2307 
        case Ident5:    *EnumParOut = Ident3;
2308 
        }
2309 
}
2310 
 
2311 
void Proc7(OneToFifty IntParI1, OneToFifty IntParI2, OneToFifty *IntParOut)
2312 
{
2313 
          OneToFifty    IntLoc;
2314 
 
2315 
        IntLoc = IntParI1 + 2;
2316 
        *IntParOut = IntParI2 + IntLoc;
2317 
}
2318 
 
2319 
void Proc8(Array1Dim    Array1Par,
2320 
      Array2Dim Array2Par,
2321 
      OneToFifty IntParI1,
2322 
      OneToFifty IntParI2)
2323 
{
2324 
          OneToFifty    IntLoc;
2325 
          OneToFifty    IntIndex;
2326 
 
2327 
        IntLoc = IntParI1 + 5;
2328 
        Array1Par[IntLoc] = IntParI2;
2329 
        Array1Par[IntLoc+1] = Array1Par[IntLoc];
2330 
        Array1Par[IntLoc+30] = IntLoc;
2331 
        for (IntIndex = IntLoc; IntIndex <= (IntLoc+1); ++IntIndex)
2332 
                Array2Par[IntLoc][IntIndex] = IntLoc;
2333 
        ++Array2Par[IntLoc][IntLoc-1];
2334 
        Array2Par[IntLoc+20][IntLoc] = Array1Par[IntLoc];
2335 
        IntGlob = 5;
2336 
}
2337 
 
2338 
Enumeration Func1(CapitalLetter CharPar1, CapitalLetter CharPar2)
2339 
{
2340 
          CapitalLetter CharLoc1;
2341 
          CapitalLetter CharLoc2;
2342 
 
2343 
        CharLoc1 = CharPar1;
2344 
        CharLoc2 = CharLoc1;
2345 
        if (CharLoc2 != CharPar2)
2346 
                return (Ident1);
2347 
        else
2348 
                return (Ident2);
2349 
}
2350 
 
2351 
boolean Func2(String30  StrParI1, String30      StrParI2)
2352 
{
2353 
          OneToThirty           IntLoc;
2354 
          CapitalLetter CharLoc;
2355 
 
2356 
        IntLoc = 1;
2357 
        while (IntLoc <= 1)
2358 
                if (Func1(StrParI1[IntLoc], StrParI2[IntLoc+1]) == Ident1)
2359 
                {
2360 
                        CharLoc = 'A';
2361 
                        ++IntLoc;
2362 
                }
2363 
        if (CharLoc >= 'W' && CharLoc <= 'Z')
2364 
                IntLoc = 7;
2365 
        if (CharLoc == 'X')
2366 
                return( 1 );
2367 
        else
2368 
        {
2369 
                if (mystrcmp(StrParI1, StrParI2) > 0)
2370 
                {
2371 
                        IntLoc += 7;
2372 
                        return (        1 );
2373 
                }
2374 
                else
2375 
                        return (        0 );
2376 
        }
2377 
}
2378 
 
2379 
boolean Func3(Enumeration       EnumParIn)
2380 
{
2381 
          Enumeration   EnumLoc;
2382 
 
2383 
        EnumLoc = EnumParIn;
2384 
        if (EnumLoc == Ident3) return ( 1 );
2385 
        return (        0 );
2386 
}

powered by: WebSVN 2.1.0

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