]>
Commit | Line | Data |
---|---|---|
d405059b | 1 | Changes for GCC version 2.95.1 for GNU Pascal 2.1 |
2 | ||
3 | Before applying these diffs, go to the directory gcc-2.95.1 | |
4 | and use the command | |
5 | ||
6 | patch -p1 | |
7 | ||
8 | feeding it the following diffs as input. | |
9 | ||
10 | *** gcc-2.95.1/gcc/expr.c.orig Thu Jul 1 00:59:55 1999 | |
11 | --- gcc-2.95.1/gcc/expr.c Sun Oct 24 14:01:38 1999 | |
12 | *************** store_constructor (exp, target, cleared) | |
13 | *** 4430,4435 **** | |
14 | --- 4430,4444 ---- | |
15 | ||
16 | domain_min = convert (sizetype, TYPE_MIN_VALUE (domain)); | |
17 | domain_max = convert (sizetype, TYPE_MAX_VALUE (domain)); | |
18 | + | |
19 | + #ifdef GPC | |
20 | + /* Align the set. */ | |
21 | + if (set_alignment) | |
22 | + domain_min = size_binop (MINUS_EXPR, domain_min, | |
23 | + size_binop (TRUNC_MOD_EXPR, domain_min, | |
24 | + size_int (set_alignment))); | |
25 | + #endif /* GPC */ | |
26 | + | |
27 | bitlength = size_binop (PLUS_EXPR, | |
28 | size_binop (MINUS_EXPR, domain_max, domain_min), | |
29 | size_one_node); | |
30 | *************** store_constructor (exp, target, cleared) | |
31 | *** 4444,4450 **** | |
32 | --- 4453,4461 ---- | |
33 | if (GET_MODE (target) != BLKmode || nbits <= 2 * BITS_PER_WORD | |
34 | || (nbytes <= 32 && TREE_CHAIN (elt) != NULL_TREE)) | |
35 | { | |
36 | + #ifndef GPC | |
37 | int set_word_size = TYPE_ALIGN (TREE_TYPE (exp)); | |
38 | + #endif /* not GPC */ | |
39 | enum machine_mode mode = mode_for_size (set_word_size, MODE_INT, 1); | |
40 | char *bit_buffer = (char *) alloca (nbits); | |
41 | HOST_WIDE_INT word = 0; | |
42 | *************** store_constructor (exp, target, cleared) | |
43 | *** 4456,4462 **** | |
44 | --- 4467,4477 ---- | |
45 | { | |
46 | if (bit_buffer[ibit]) | |
47 | { | |
48 | + #ifdef GPC | |
49 | + if (set_words_big_endian) | |
50 | + #else /* not GPC */ | |
51 | if (BYTES_BIG_ENDIAN) | |
52 | + #endif /* not GPC */ | |
53 | word |= (1 << (set_word_size - 1 - bit_pos)); | |
54 | else | |
55 | word |= 1 << bit_pos; | |
56 | *************** store_constructor (exp, target, cleared) | |
57 | *** 4570,4575 **** | |
58 | --- 4585,4596 ---- | |
59 | else | |
60 | #endif | |
61 | { | |
62 | + #ifdef GPC | |
63 | + /* The language-specific run time library must provide | |
64 | + a suitable `__setbits()' function whose action coincides | |
65 | + with the values of `set_word_size', `set_alignment', and | |
66 | + `set_words_big_endian'. */ | |
67 | + #endif /* GPC */ | |
68 | emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"), | |
69 | 0, VOIDmode, 4, XEXP (targetx, 0), Pmode, | |
70 | bitlength_rtx, TYPE_MODE (sizetype), | |
71 | *** gcc-2.95.1/gcc/stor-layout.c.orig Thu Mar 11 14:56:20 1999 | |
72 | --- gcc-2.95.1/gcc/stor-layout.c Wed Oct 27 16:39:10 1999 | |
73 | *************** int maximum_field_alignment; | |
74 | *** 53,58 **** | |
75 | --- 53,69 ---- | |
76 | May be overridden by front-ends. */ | |
77 | int set_alignment = 0; | |
78 | ||
79 | + #ifdef GPC | |
80 | + /* The word size of a bitstring or (power-)set value, in bits. | |
81 | + Must be non-zero. | |
82 | + May be overridden by front-ends. */ | |
83 | + int set_word_size = BITS_PER_UNIT; | |
84 | + | |
85 | + /* If non-zero, bits in (power-)sets start with the highest bit. | |
86 | + May be overridden by front-ends. */ | |
87 | + int set_words_big_endian /*= BYTES_BIG_ENDIAN*/; /* @@@ Needn't be a constant! */ | |
88 | + #endif /* GPC */ | |
89 | + | |
90 | static tree layout_record PROTO((tree)); | |
91 | static void layout_union PROTO((tree)); | |
92 | \f | |
93 | *************** static tree pending_sizes; | |
94 | *** 65,70 **** | |
95 | --- 76,88 ---- | |
96 | ||
97 | int immediate_size_expand; | |
98 | ||
99 | + #ifdef GPC | |
100 | + /* Nonzero means that the size of a type may vary | |
101 | + within one function context. */ | |
102 | + | |
103 | + int size_volatile = 0; | |
104 | + #endif /* GPC */ | |
105 | + | |
106 | tree | |
107 | get_pending_sizes () | |
108 | { | |
109 | *************** variable_size (size) | |
110 | *** 102,108 **** | |
111 | --- 120,131 ---- | |
112 | || global_bindings_p () < 0 || contains_placeholder_p (size)) | |
113 | return size; | |
114 | ||
115 | + #ifdef GPC | |
116 | + if (! size_volatile) | |
117 | + size = save_expr (size); | |
118 | + #else /* not GPC */ | |
119 | size = save_expr (size); | |
120 | + #endif | |
121 | ||
122 | if (global_bindings_p ()) | |
123 | { | |
124 | *************** variable_size (size) | |
125 | *** 119,125 **** | |
126 | --- 142,152 ---- | |
127 | Also, we would like to pass const0_rtx here, but don't have it. */ | |
128 | expand_expr (size, expand_expr (integer_zero_node, NULL_PTR, VOIDmode, 0), | |
129 | VOIDmode, 0); | |
130 | + #ifdef GPC | |
131 | + else if (! size_volatile) | |
132 | + #else /* not GPC */ | |
133 | else | |
134 | + #endif | |
135 | pending_sizes = tree_cons (NULL_TREE, size, pending_sizes); | |
136 | ||
137 | return size; | |
138 | *************** layout_type (type) | |
139 | *** 1040,1045 **** | |
140 | --- 1067,1086 ---- | |
141 | abort(); | |
142 | else | |
143 | { | |
144 | + #ifdef GPC | |
145 | + int alignment = set_alignment ? set_alignment : set_word_size; | |
146 | + int lower_bound = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))); | |
147 | + int upper_bound = TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))); | |
148 | + int size_in_bits, rounded_size; | |
149 | + if (set_alignment) | |
150 | + size_in_bits = upper_bound - (lower_bound / alignment) * alignment + 1; | |
151 | + else | |
152 | + size_in_bits | |
153 | + = (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) | |
154 | + - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1); | |
155 | + rounded_size | |
156 | + = ((size_in_bits + alignment - 1) / alignment) * alignment; | |
157 | + #else /* not GPC */ | |
158 | #ifndef SET_WORD_SIZE | |
159 | #define SET_WORD_SIZE BITS_PER_WORD | |
160 | #endif | |
161 | *************** layout_type (type) | |
162 | *** 1049,1054 **** | |
163 | --- 1090,1096 ---- | |
164 | - TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (type))) + 1); | |
165 | int rounded_size | |
166 | = ((size_in_bits + alignment - 1) / alignment) * alignment; | |
167 | + #endif /* not GPC */ | |
168 | if (rounded_size > alignment) | |
169 | TYPE_MODE (type) = BLKmode; | |
170 | else | |
171 | *** gcc-2.95.1/gcc/tree.c.orig Wed Sep 29 19:41:05 1999 | |
172 | --- gcc-2.95.1/gcc/tree.c Tue Oct 19 00:04:25 1999 | |
173 | *************** get_set_constructor_bits (init, buffer, | |
174 | *** 4986,4991 **** | |
175 | --- 4986,4998 ---- | |
176 | HOST_WIDE_INT domain_min | |
177 | = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init)))); | |
178 | tree non_const_bits = NULL_TREE; | |
179 | + | |
180 | + #ifdef GPC | |
181 | + /* Align the set. */ | |
182 | + if (set_alignment) | |
183 | + domain_min -= domain_min % set_alignment; | |
184 | + #endif /* GPC */ | |
185 | + | |
186 | for (i = 0; i < bit_size; i++) | |
187 | buffer[i] = 0; | |
188 | ||
189 | *************** get_set_constructor_bytes (init, buffer, | |
190 | *** 5038,5045 **** | |
191 | --- 5045,5056 ---- | |
192 | int wd_size; | |
193 | { | |
194 | int i; | |
195 | + #ifdef GPC | |
196 | + int bit_size = wd_size * BITS_PER_UNIT; | |
197 | + #else /* not GPC */ | |
198 | int set_word_size = BITS_PER_UNIT; | |
199 | int bit_size = wd_size * set_word_size; | |
200 | + #endif /* not GPC */ | |
201 | int bit_pos = 0; | |
202 | unsigned char *bytep = buffer; | |
203 | char *bit_buffer = (char *) alloca(bit_size); | |
204 | *************** get_set_constructor_bytes (init, buffer, | |
205 | *** 5050,5055 **** | |
206 | --- 5061,5084 ---- | |
207 | ||
208 | for (i = 0; i < bit_size; i++) | |
209 | { | |
210 | + #ifdef GPC | |
211 | + if (bit_buffer[i]) | |
212 | + { | |
213 | + int k = bit_pos / BITS_PER_UNIT; | |
214 | + if (WORDS_BIG_ENDIAN) | |
215 | + k = set_word_size / BITS_PER_UNIT - 1 - k; | |
216 | + if (set_words_big_endian) | |
217 | + bytep[k] |= (1 << (BITS_PER_UNIT - 1 - bit_pos % BITS_PER_UNIT)); | |
218 | + else | |
219 | + bytep[k] |= 1 << (bit_pos % BITS_PER_UNIT); | |
220 | + } | |
221 | + bit_pos++; | |
222 | + if (bit_pos >= set_word_size) | |
223 | + { | |
224 | + bit_pos = 0; | |
225 | + bytep += set_word_size / BITS_PER_UNIT; | |
226 | + } | |
227 | + #else /* not GPC */ | |
228 | if (bit_buffer[i]) | |
229 | { | |
230 | if (BYTES_BIG_ENDIAN) | |
231 | *************** get_set_constructor_bytes (init, buffer, | |
232 | *** 5060,5065 **** | |
233 | --- 5089,5095 ---- | |
234 | bit_pos++; | |
235 | if (bit_pos >= set_word_size) | |
236 | bit_pos = 0, bytep++; | |
237 | + #endif /* not GPC */ | |
238 | } | |
239 | return non_const_bits; | |
240 | } | |
241 | *** gcc-2.95.1/gcc/tree.h.orig Mon Oct 18 12:19:46 1999 | |
242 | --- gcc-2.95.1/gcc/tree.h Mon Oct 18 12:36:04 1999 | |
243 | *************** extern int maximum_field_alignment; | |
244 | *** 1630,1635 **** | |
245 | --- 1630,1643 ---- | |
246 | /* If non-zero, the alignment of a bitstring or (power-)set value, in bits. */ | |
247 | extern int set_alignment; | |
248 | ||
249 | + #ifdef GPC | |
250 | + /* The word size of a bitstring or (power-)set value, in bits. */ | |
251 | + extern int set_word_size; | |
252 | + | |
253 | + /* If non-zero, bits in (power-)sets start with the highest bit. */ | |
254 | + extern int set_words_big_endian; | |
255 | + #endif /* GPC */ | |
256 | + | |
257 | /* Concatenate two lists (chains of TREE_LIST nodes) X and Y | |
258 | by making the last node in X point to Y. | |
259 | Returns X, except if X is 0 returns Y. */ | |
260 | *** gcc-2.95.1/gcc/tree.def.orig Mon May 17 09:21:12 1999 | |
261 | --- gcc-2.95.1/gcc/tree.def Tue Oct 26 04:16:43 1999 | |
262 | *************** DEFTREECODE (WITH_CLEANUP_EXPR, "with_cl | |
263 | *** 490,528 **** | |
264 | DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1) | |
265 | ||
266 | /* The following two codes are used in languages that have types where | |
267 | ! the position and/or sizes of fields vary from object to object of the | |
268 | ! same type, i.e., where some other field in the object contains a value | |
269 | ! that is used in the computation of another field's offset or size. | |
270 | ! | |
271 | ! For example, a record type with a discriminant in Ada is such a type. | |
272 | ! This mechanism is also used to create "fat pointers" for unconstrained | |
273 | ! array types in Ada; the fat pointer is a structure one of whose fields is | |
274 | ! a pointer to the actual array type and the other field is a pointer to a | |
275 | ! template, which is a structure containing the bounds of the array. The | |
276 | ! bounds in the type pointed to by the first field in the fat pointer refer | |
277 | ! to the values in the template. | |
278 | ! | |
279 | ! These "self-references" are doing using a PLACEHOLDER_EXPR. This is a | |
280 | ! node that will later be replaced with the object being referenced. Its type | |
281 | ! is that of the object and selects which object to use from a chain of | |
282 | ! references (see below). | |
283 | ! | |
284 | ! When we wish to evaluate a size or offset, we check it is contains a | |
285 | ! placeholder. If it does, we construct a WITH_RECORD_EXPR that contains | |
286 | ! both the expression we wish to evaluate and an expression within which the | |
287 | ! object may be found. The latter expression is the object itself in | |
288 | ! the simple case of an Ada record with discriminant, but it can be the | |
289 | ! array in the case of an unconstrained array. | |
290 | ! | |
291 | ! In the latter case, we need the fat pointer, because the bounds of the | |
292 | ! array can only be accessed from it. However, we rely here on the fact that | |
293 | ! the expression for the array contains the dereference of the fat pointer | |
294 | ! that obtained the array pointer. | |
295 | ||
296 | Accordingly, when looking for the object to substitute in place of | |
297 | a PLACEHOLDER_EXPR, we look down the first operand of the expression | |
298 | ! passed as the second operand to WITH_RECORD_EXPR until we find something | |
299 | ! of the desired type or reach a constant. */ | |
300 | ||
301 | /* Denotes a record to later be supplied with a WITH_RECORD_EXPR when | |
302 | evaluating this expression. The type of this expression is used to | |
303 | --- 490,547 ---- | |
304 | DEFTREECODE (CLEANUP_POINT_EXPR, "cleanup_point_expr", 'e', 1) | |
305 | ||
306 | /* The following two codes are used in languages that have types where | |
307 | ! some field in an object of the type contains a value that is used in | |
308 | ! the computation of another field's offset or size and/or the size of | |
309 | ! the type. The positions and/or sizes of fields can vary from object | |
310 | ! to object of the same type or even for one and the same object within | |
311 | ! its scope. | |
312 | ! | |
313 | ! Record types with discriminants in Ada or schema types in Pascal are | |
314 | ! examples of such types. This mechanism is also used to create "fat | |
315 | ! pointers" for unconstrained array types in Ada; the fat pointer is a | |
316 | ! structure one of whose fields is a pointer to the actual array type | |
317 | ! and the other field is a pointer to a template, which is a structure | |
318 | ! containing the bounds of the array. The bounds in the type pointed | |
319 | ! to by the first field in the fat pointer refer to the values in the | |
320 | ! template. | |
321 | ! | |
322 | ! When you wish to construct such a type you need "self-references" | |
323 | ! that allow you to reference the object having this type from the | |
324 | ! TYPE node, i.e. without having a variable instantiating this type. | |
325 | ! | |
326 | ! Such a "self-references" is done using a PLACEHOLDER_EXPR. This is | |
327 | ! a node that will later be replaced with the object being referenced. | |
328 | ! Its type is that of the object and selects which object to use from | |
329 | ! a chain of references (see below). No other slots are used in the | |
330 | ! PLACEHOLDER_EXPR. | |
331 | ! | |
332 | ! For example, if your type FOO is a RECORD_TYPE with a field BAR, | |
333 | ! and you need the value of <variable>.BAR to calculate TYPE_SIZE | |
334 | ! (FOO), just substitute <variable> above with a PLACEHOLDER_EXPR | |
335 | ! whose TREE_TYPE is FOO. Then construct your COMPONENT_REF with | |
336 | ! the PLACEHOLDER_EXPR as the first operand (which has the correct | |
337 | ! type). Later, when the size is needed in the program, the back-end | |
338 | ! will find this PLACEHOLDER_EXPR and generate code to calculate the | |
339 | ! actual size at run-time. In the following, we describe how this | |
340 | ! calculation is done. | |
341 | ! | |
342 | ! When we wish to evaluate a size or offset, we check whether it | |
343 | ! contains a PLACEHOLDER_EXPR. If it does, we construct a | |
344 | ! WITH_RECORD_EXPR that contains both the expression we wish to | |
345 | ! evaluate and an expression within which the object may be found. | |
346 | ! The latter expression is the object itself in the simple case of an | |
347 | ! Ada record with discriminant, but it can be the array in the case of | |
348 | ! an unconstrained array. | |
349 | ! | |
350 | ! In the latter case, we need the fat pointer, because the bounds of | |
351 | ! the array can only be accessed from it. However, we rely here on the | |
352 | ! fact that the expression for the array contains the dereference of | |
353 | ! the fat pointer that obtained the array pointer. | |
354 | ||
355 | Accordingly, when looking for the object to substitute in place of | |
356 | a PLACEHOLDER_EXPR, we look down the first operand of the expression | |
357 | ! passed as the second operand to WITH_RECORD_EXPR until we find | |
358 | ! something of the desired type or reach a constant. */ | |
359 | ||
360 | /* Denotes a record to later be supplied with a WITH_RECORD_EXPR when | |
361 | evaluating this expression. The type of this expression is used to |