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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.c-torture/] [unsorted/] [USIcmp.c] - Blame information for rev 688

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 688 jeremybenn
#define type unsigned int
2
 
3
type glob0, glob1;
4
 
5
#define E0 ((type *)10000000)
6
#define reg0 r0
7
#define indreg0 (*p0)
8
#define imm0 22
9
#define limm0 ((type)&glob0)
10
#define adr0 (*E0)
11
#define adrreg0 (p0[10000000])
12
#define adrx0 (E0[x0])
13
#define regx0 (p0[x0])
14
 
15
#define E1 ((type *)(11111111 & ~(__alignof__ (type) - 1)))
16
#define reg1 r1
17
#define indreg1 (*p1)
18
#define imm1 33
19
#define limm1 ((type)&glob1)
20
#define adr1 (*E1)
21
#define adrreg1 (p1[1111111/4])
22
#define adrx1 (E1[x1])
23
#define regx1 (p1[x1])
24
 
25
reg0reg1 (r0, r1, x0, x1, p0, p1)
26
type r0, r1;  type *p0, *p1;
27
{if (reg0 <= reg1) return 1; else return 0;}
28
 
29
reg0indreg1 (r0, r1, x0, x1, p0, p1)
30
type r0, r1;  type *p0, *p1;
31
{if (reg0 <= indreg1) return 1; else return 0;}
32
 
33
reg0imm1 (r0, r1, x0, x1, p0, p1)
34
type r0, r1;  type *p0, *p1;
35
{if (reg0 <= imm1) return 1; else return 0;}
36
 
37
reg0limm1 (r0, r1, x0, x1, p0, p1)
38
type r0, r1;  type *p0, *p1;
39
{if (reg0 <= limm1) return 1; else return 0;}
40
 
41
reg0adr1 (r0, r1, x0, x1, p0, p1)
42
type r0, r1;  type *p0, *p1;
43
{if (reg0 <= adr1) return 1; else return 0;}
44
 
45
reg0adrreg1 (r0, r1, x0, x1, p0, p1)
46
type r0, r1;  type *p0, *p1;
47
{if (reg0 <= adrreg1) return 1; else return 0;}
48
 
49
reg0adrx1 (r0, r1, x0, x1, p0, p1)
50
type r0, r1;  type *p0, *p1;
51
{if (reg0 <= adrx1) return 1; else return 0;}
52
 
53
reg0regx1 (r0, r1, x0, x1, p0, p1)
54
type r0, r1;  type *p0, *p1;
55
{if (reg0 <= regx1) return 1; else return 0;}
56
 
57
indreg0reg1 (r0, r1, x0, x1, p0, p1)
58
type r0, r1;  type *p0, *p1;
59
{if (indreg0 <= reg1) return 1; else return 0;}
60
 
61
indreg0indreg1 (r0, r1, x0, x1, p0, p1)
62
type r0, r1;  type *p0, *p1;
63
{if (indreg0 <= indreg1) return 1; else return 0;}
64
 
65
indreg0imm1 (r0, r1, x0, x1, p0, p1)
66
type r0, r1;  type *p0, *p1;
67
{if (indreg0 <= imm1) return 1; else return 0;}
68
 
69
indreg0limm1 (r0, r1, x0, x1, p0, p1)
70
type r0, r1;  type *p0, *p1;
71
{if (indreg0 <= limm1) return 1; else return 0;}
72
 
73
indreg0adr1 (r0, r1, x0, x1, p0, p1)
74
type r0, r1;  type *p0, *p1;
75
{if (indreg0 <= adr1) return 1; else return 0;}
76
 
77
indreg0adrreg1 (r0, r1, x0, x1, p0, p1)
78
type r0, r1;  type *p0, *p1;
79
{if (indreg0 <= adrreg1) return 1; else return 0;}
80
 
81
indreg0adrx1 (r0, r1, x0, x1, p0, p1)
82
type r0, r1;  type *p0, *p1;
83
{if (indreg0 <= adrx1) return 1; else return 0;}
84
 
85
indreg0regx1 (r0, r1, x0, x1, p0, p1)
86
type r0, r1;  type *p0, *p1;
87
{if (indreg0 <= regx1) return 1; else return 0;}
88
 
89
imm0reg1 (r0, r1, x0, x1, p0, p1)
90
type r0, r1;  type *p0, *p1;
91
{if (imm0 <= reg1) return 1; else return 0;}
92
 
93
imm0indreg1 (r0, r1, x0, x1, p0, p1)
94
type r0, r1;  type *p0, *p1;
95
{if (imm0 <= indreg1) return 1; else return 0;}
96
 
97
imm0imm1 (r0, r1, x0, x1, p0, p1)
98
type r0, r1;  type *p0, *p1;
99
{if (imm0 <= imm1) return 1; else return 0;}
100
 
101
imm0limm1 (r0, r1, x0, x1, p0, p1)
102
type r0, r1;  type *p0, *p1;
103
{if (imm0 <= limm1) return 1; else return 0;}
104
 
105
imm0adr1 (r0, r1, x0, x1, p0, p1)
106
type r0, r1;  type *p0, *p1;
107
{if (imm0 <= adr1) return 1; else return 0;}
108
 
109
imm0adrreg1 (r0, r1, x0, x1, p0, p1)
110
type r0, r1;  type *p0, *p1;
111
{if (imm0 <= adrreg1) return 1; else return 0;}
112
 
113
imm0adrx1 (r0, r1, x0, x1, p0, p1)
114
type r0, r1;  type *p0, *p1;
115
{if (imm0 <= adrx1) return 1; else return 0;}
116
 
117
imm0regx1 (r0, r1, x0, x1, p0, p1)
118
type r0, r1;  type *p0, *p1;
119
{if (imm0 <= regx1) return 1; else return 0;}
120
 
121
limm0reg1 (r0, r1, x0, x1, p0, p1)
122
type r0, r1;  type *p0, *p1;
123
{if (limm0 <= reg1) return 1; else return 0;}
124
 
125
limm0indreg1 (r0, r1, x0, x1, p0, p1)
126
type r0, r1;  type *p0, *p1;
127
{if (limm0 <= indreg1) return 1; else return 0;}
128
 
129
limm0imm1 (r0, r1, x0, x1, p0, p1)
130
type r0, r1;  type *p0, *p1;
131
{if (limm0 <= imm1) return 1; else return 0;}
132
 
133
limm0limm1 (r0, r1, x0, x1, p0, p1)
134
type r0, r1;  type *p0, *p1;
135
{if (limm0 <= limm1) return 1; else return 0;}
136
 
137
limm0adr1 (r0, r1, x0, x1, p0, p1)
138
type r0, r1;  type *p0, *p1;
139
{if (limm0 <= adr1) return 1; else return 0;}
140
 
141
limm0adrreg1 (r0, r1, x0, x1, p0, p1)
142
type r0, r1;  type *p0, *p1;
143
{if (limm0 <= adrreg1) return 1; else return 0;}
144
 
145
limm0adrx1 (r0, r1, x0, x1, p0, p1)
146
type r0, r1;  type *p0, *p1;
147
{if (limm0 <= adrx1) return 1; else return 0;}
148
 
149
limm0regx1 (r0, r1, x0, x1, p0, p1)
150
type r0, r1;  type *p0, *p1;
151
{if (limm0 <= regx1) return 1; else return 0;}
152
 
153
adr0reg1 (r0, r1, x0, x1, p0, p1)
154
type r0, r1;  type *p0, *p1;
155
{if (adr0 <= reg1) return 1; else return 0;}
156
 
157
adr0indreg1 (r0, r1, x0, x1, p0, p1)
158
type r0, r1;  type *p0, *p1;
159
{if (adr0 <= indreg1) return 1; else return 0;}
160
 
161
adr0imm1 (r0, r1, x0, x1, p0, p1)
162
type r0, r1;  type *p0, *p1;
163
{if (adr0 <= imm1) return 1; else return 0;}
164
 
165
adr0limm1 (r0, r1, x0, x1, p0, p1)
166
type r0, r1;  type *p0, *p1;
167
{if (adr0 <= limm1) return 1; else return 0;}
168
 
169
adr0adr1 (r0, r1, x0, x1, p0, p1)
170
type r0, r1;  type *p0, *p1;
171
{if (adr0 <= adr1) return 1; else return 0;}
172
 
173
adr0adrreg1 (r0, r1, x0, x1, p0, p1)
174
type r0, r1;  type *p0, *p1;
175
{if (adr0 <= adrreg1) return 1; else return 0;}
176
 
177
adr0adrx1 (r0, r1, x0, x1, p0, p1)
178
type r0, r1;  type *p0, *p1;
179
{if (adr0 <= adrx1) return 1; else return 0;}
180
 
181
adr0regx1 (r0, r1, x0, x1, p0, p1)
182
type r0, r1;  type *p0, *p1;
183
{if (adr0 <= regx1) return 1; else return 0;}
184
 
185
adrreg0reg1 (r0, r1, x0, x1, p0, p1)
186
type r0, r1;  type *p0, *p1;
187
{if (adrreg0 <= reg1) return 1; else return 0;}
188
 
189
adrreg0indreg1 (r0, r1, x0, x1, p0, p1)
190
type r0, r1;  type *p0, *p1;
191
{if (adrreg0 <= indreg1) return 1; else return 0;}
192
 
193
adrreg0imm1 (r0, r1, x0, x1, p0, p1)
194
type r0, r1;  type *p0, *p1;
195
{if (adrreg0 <= imm1) return 1; else return 0;}
196
 
197
adrreg0limm1 (r0, r1, x0, x1, p0, p1)
198
type r0, r1;  type *p0, *p1;
199
{if (adrreg0 <= limm1) return 1; else return 0;}
200
 
201
adrreg0adr1 (r0, r1, x0, x1, p0, p1)
202
type r0, r1;  type *p0, *p1;
203
{if (adrreg0 <= adr1) return 1; else return 0;}
204
 
205
adrreg0adrreg1 (r0, r1, x0, x1, p0, p1)
206
type r0, r1;  type *p0, *p1;
207
{if (adrreg0 <= adrreg1) return 1; else return 0;}
208
 
209
adrreg0adrx1 (r0, r1, x0, x1, p0, p1)
210
type r0, r1;  type *p0, *p1;
211
{if (adrreg0 <= adrx1) return 1; else return 0;}
212
 
213
adrreg0regx1 (r0, r1, x0, x1, p0, p1)
214
type r0, r1;  type *p0, *p1;
215
{if (adrreg0 <= regx1) return 1; else return 0;}
216
 
217
adrx0reg1 (r0, r1, x0, x1, p0, p1)
218
type r0, r1;  type *p0, *p1;
219
{if (adrx0 <= reg1) return 1; else return 0;}
220
 
221
adrx0indreg1 (r0, r1, x0, x1, p0, p1)
222
type r0, r1;  type *p0, *p1;
223
{if (adrx0 <= indreg1) return 1; else return 0;}
224
 
225
adrx0imm1 (r0, r1, x0, x1, p0, p1)
226
type r0, r1;  type *p0, *p1;
227
{if (adrx0 <= imm1) return 1; else return 0;}
228
 
229
adrx0limm1 (r0, r1, x0, x1, p0, p1)
230
type r0, r1;  type *p0, *p1;
231
{if (adrx0 <= limm1) return 1; else return 0;}
232
 
233
adrx0adr1 (r0, r1, x0, x1, p0, p1)
234
type r0, r1;  type *p0, *p1;
235
{if (adrx0 <= adr1) return 1; else return 0;}
236
 
237
adrx0adrreg1 (r0, r1, x0, x1, p0, p1)
238
type r0, r1;  type *p0, *p1;
239
{if (adrx0 <= adrreg1) return 1; else return 0;}
240
 
241
adrx0adrx1 (r0, r1, x0, x1, p0, p1)
242
type r0, r1;  type *p0, *p1;
243
{if (adrx0 <= adrx1) return 1; else return 0;}
244
 
245
adrx0regx1 (r0, r1, x0, x1, p0, p1)
246
type r0, r1;  type *p0, *p1;
247
{if (adrx0 <= regx1) return 1; else return 0;}
248
 
249
regx0reg1 (r0, r1, x0, x1, p0, p1)
250
type r0, r1;  type *p0, *p1;
251
{if (regx0 <= reg1) return 1; else return 0;}
252
 
253
regx0indreg1 (r0, r1, x0, x1, p0, p1)
254
type r0, r1;  type *p0, *p1;
255
{if (regx0 <= indreg1) return 1; else return 0;}
256
 
257
regx0imm1 (r0, r1, x0, x1, p0, p1)
258
type r0, r1;  type *p0, *p1;
259
{if (regx0 <= imm1) return 1; else return 0;}
260
 
261
regx0limm1 (r0, r1, x0, x1, p0, p1)
262
type r0, r1;  type *p0, *p1;
263
{if (regx0 <= limm1) return 1; else return 0;}
264
 
265
regx0adr1 (r0, r1, x0, x1, p0, p1)
266
type r0, r1;  type *p0, *p1;
267
{if (regx0 <= adr1) return 1; else return 0;}
268
 
269
regx0adrreg1 (r0, r1, x0, x1, p0, p1)
270
type r0, r1;  type *p0, *p1;
271
{if (regx0 <= adrreg1) return 1; else return 0;}
272
 
273
regx0adrx1 (r0, r1, x0, x1, p0, p1)
274
type r0, r1;  type *p0, *p1;
275
{if (regx0 <= adrx1) return 1; else return 0;}
276
 
277
regx0regx1 (r0, r1, x0, x1, p0, p1)
278
type r0, r1;  type *p0, *p1;
279
{if (regx0 <= regx1) return 1; else return 0;}
280
 

powered by: WebSVN 2.1.0

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