OSDN Git Service

* config/alpha/vms.h (INCLUDE_DEFAULTS): Add /gnu/lib/gcc-lib/include.
[pf3gnuchains/gcc-fork.git] / gcc / ch / xtypeck.c
1 /* Copyright (C) 1992, 1993, 1994, 1998 Free Software Foundation, Inc.
2
3 This file is part of GNU CC.
4
5 GNU CC is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2, or (at your option)
8 any later version.
9
10 GNU CC is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GNU CC; see the file COPYING.  If not, write to
17 the Free Software Foundation, 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.  */
19
20
21 #if 0
22 tree
23 build_component_ref (datum, field_name)
24   tree datum, field_name;
25 {
26   return build_chill_component_ref (datum, field_name);
27 }
28
29 /* Mark EXP saying that we need to be able to take the
30    address of it; it should not be allocated in a register.
31    Value is 1 if successful.  */
32
33 int
34 mark_addressable (exp)
35      tree exp;
36 {
37   register tree x = exp;
38   while (1)
39     switch (TREE_CODE (x))
40       {
41       case ADDR_EXPR:
42       case COMPONENT_REF:
43       case ARRAY_REF:
44       case REALPART_EXPR:
45       case IMAGPART_EXPR:
46         x = TREE_OPERAND (x, 0);
47         break;
48
49       case CONSTRUCTOR:
50         TREE_ADDRESSABLE (x) = 1;
51         return 1;
52
53       case VAR_DECL:
54       case CONST_DECL:
55       case PARM_DECL:
56       case RESULT_DECL:
57         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
58             && DECL_NONLOCAL (x))
59           {
60             if (TREE_PUBLIC (x))
61               {
62                 error ("global register variable `%s' used in nested function",
63                        IDENTIFIER_POINTER (DECL_NAME (x)));
64                 return 0;
65               }
66             pedwarn ("register variable `%s' used in nested function",
67                      IDENTIFIER_POINTER (DECL_NAME (x)));
68           }
69         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
70           {
71             if (TREE_PUBLIC (x))
72               {
73                 error ("address of global register variable `%s' requested",
74                        IDENTIFIER_POINTER (DECL_NAME (x)));
75                 return 0;
76               }
77
78             /* If we are making this addressable due to its having
79                volatile components, give a different error message.  Also
80                handle the case of an unnamed parameter by not trying
81                to give the name.  */
82
83             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
84               {
85                 error ("cannot put object with volatile field into register");
86                 return 0;
87               }
88
89             pedwarn ("address of register variable `%s' requested",
90                      IDENTIFIER_POINTER (DECL_NAME (x)));
91           }
92         put_var_into_stack (x);
93
94         /* drops in */
95       case FUNCTION_DECL:
96         TREE_ADDRESSABLE (x) = 1;
97 #if 0  /* poplevel deals with this now.  */
98         if (DECL_CONTEXT (x) == 0)
99           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
100 #endif
101
102       default:
103         return 1;
104     }
105 }
106
107 /* Return an unsigned type the same as TYPE in other respects.  */
108
109 tree
110 unsigned_type (type)
111      tree type;
112 {
113   tree type1 = TYPE_MAIN_VARIANT (type);
114   if (type1 == signed_char_type_node || type1 == char_type_node)
115     return unsigned_char_type_node;
116   if (type1 == integer_type_node)
117     return unsigned_type_node;
118   if (type1 == short_integer_type_node)
119     return short_unsigned_type_node;
120   if (type1 == long_integer_type_node)
121     return long_unsigned_type_node;
122   if (type1 == long_long_integer_type_node)
123     return long_long_unsigned_type_node;
124   return type;
125 }
126
127 /* Return a signed type the same as TYPE in other respects.  */
128
129 tree
130 signed_type (type)
131      tree type;
132 {
133   tree type1 = TYPE_MAIN_VARIANT (type);
134   if (type1 == unsigned_char_type_node || type1 == char_type_node)
135     return signed_char_type_node;
136   if (type1 == unsigned_type_node)
137     return integer_type_node;
138   if (type1 == short_unsigned_type_node)
139     return short_integer_type_node;
140   if (type1 == long_unsigned_type_node)
141     return long_integer_type_node;
142   if (type1 == long_long_unsigned_type_node)
143     return long_long_integer_type_node;
144   return type;
145 }
146
147 /* Return a type the same as TYPE except unsigned or
148    signed according to UNSIGNEDP.  */
149
150 tree
151 signed_or_unsigned_type (unsignedp, type)
152      int unsignedp;
153      tree type;
154 {
155   if (! INTEGRAL_TYPE_P (type))
156     return type;
157   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
158     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
159   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 
160     return unsignedp ? unsigned_type_node : integer_type_node;
161   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node)) 
162     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
163   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node)) 
164     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
165   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node)) 
166     return (unsignedp ? long_long_unsigned_type_node
167             : long_long_integer_type_node);
168   return type;
169 }
170
171 extern tree intHI_type_node;
172 extern tree intSI_type_node;
173 extern tree intDI_type_node;
174
175 extern tree unsigned_intHI_type_node;
176 extern tree unsigned_intSI_type_node;
177 extern tree unsigned_intDI_type_node;
178
179 /* Return an integer type with BITS bits of precision,
180    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
181
182 tree
183 type_for_size (bits, unsignedp)
184      unsigned bits;
185      int unsignedp;
186 {
187   if (bits == TYPE_PRECISION (signed_char_type_node))
188     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
189
190   if (bits == TYPE_PRECISION (short_integer_type_node))
191     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
192
193   if (bits == TYPE_PRECISION (integer_type_node))
194     return unsignedp ? unsigned_type_node : integer_type_node;
195
196   if (bits == TYPE_PRECISION (long_integer_type_node))
197     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
198
199   if (bits == TYPE_PRECISION (long_long_integer_type_node))
200     return (unsignedp ? long_long_unsigned_type_node
201             : long_long_integer_type_node);
202
203   if (bits <= TYPE_PRECISION (intHI_type_node))
204     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
205
206   if (bits <= TYPE_PRECISION (intSI_type_node))
207     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
208
209   if (bits <= TYPE_PRECISION (intDI_type_node))
210     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
211
212   return 0;
213 }
214
215 /* Return a data type that has machine mode MODE.
216    If the mode is an integer,
217    then UNSIGNEDP selects between signed and unsigned types.  */
218
219 tree
220 type_for_mode (mode, unsignedp)
221      enum machine_mode mode;
222      int unsignedp;
223 {
224   if (mode == TYPE_MODE (signed_char_type_node))
225     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
226
227   if (mode == TYPE_MODE (short_integer_type_node))
228     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
229
230   if (mode == TYPE_MODE (integer_type_node))
231     return unsignedp ? unsigned_type_node : integer_type_node;
232
233   if (mode == TYPE_MODE (long_integer_type_node))
234     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
235
236   if (mode == TYPE_MODE (long_long_integer_type_node))
237     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
238
239   if (mode == TYPE_MODE (intHI_type_node))
240     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
241
242   if (mode == TYPE_MODE (intSI_type_node))
243     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
244
245   if (mode == TYPE_MODE (intDI_type_node))
246     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
247
248   if (mode == TYPE_MODE (float_type_node))
249     return float_type_node;
250
251   if (mode == TYPE_MODE (double_type_node))
252     return double_type_node;
253
254   if (mode == TYPE_MODE (long_double_type_node))
255     return long_double_type_node;
256
257   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
258     return build_pointer_type (char_type_node);
259
260   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
261     return build_pointer_type (integer_type_node);
262
263   return 0;
264 }
265
266 tree
267 truthvalue_conversion (expr)
268      tree expr;
269 {
270   return chill_truthvalue_conversion (expr);
271 }
272 #endif