OSDN Git Service

* config/alpha/vms.h (INCLUDE_DEFAULTS): Add /gnu/lib/gcc-lib/include.
[pf3gnuchains/gcc-fork.git] / gcc / ch / satisfy.c
1 /* Name-satisfaction for GNU Chill compiler.
2    Copyright (C) 1993, 1998, 1999, 2000 Free Software Foundation, Inc.
3
4 This file is part of GNU CC.
5
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING.  If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "tree.h"
24 #include "flags.h"
25 #include "ch-tree.h"
26 #include "lex.h"
27 #include "toplev.h"
28
29 #define SATISFY(ARG) ((ARG) = satisfy(ARG, chain))
30
31 struct decl_chain
32 {
33   struct decl_chain *prev;
34   /* DECL can be a decl, or a POINTER_TYPE or a REFERENCE_TYPE. */
35   tree decl;
36 };
37
38 /* forward declarations */
39 static tree satisfy             PARAMS ((tree, struct decl_chain *));
40 static void cycle_error_print   PARAMS ((struct decl_chain *, tree));
41 static tree safe_satisfy_decl   PARAMS ((tree, struct decl_chain *));
42 static void satisfy_list        PARAMS ((tree, struct decl_chain *));
43 static void satisfy_list_values PARAMS ((tree, struct decl_chain *));
44
45 static struct decl_chain dummy_chain;
46 #define LOOKUP_ONLY (chain==&dummy_chain)
47
48 /* Recursive helper routine to logically reverse the chain. */
49 static void
50 cycle_error_print (chain, decl)
51      struct decl_chain *chain;
52      tree decl;
53 {
54   if (chain->decl != decl)
55     {
56       cycle_error_print (chain->prev, decl);
57       if (TREE_CODE_CLASS (TREE_CODE (chain->decl)) == 'd')
58         error_with_decl (chain->decl, "  `%s', which depends on ...");
59     }
60 }
61
62 static tree
63 safe_satisfy_decl (decl, prev_chain)
64      tree decl;
65      struct decl_chain *prev_chain;
66 {
67   struct decl_chain new_link;
68   struct decl_chain *link;
69   struct decl_chain *chain = prev_chain;
70   const char *save_filename = input_filename;
71   int save_lineno = lineno;
72   tree result = decl;
73   
74   if (decl == NULL_TREE)
75     return decl;
76
77   if (!LOOKUP_ONLY)
78     {
79       int pointer_type_breaks_cycle = 0;
80       /* Look for a cycle.
81          We could do this test more efficiently by setting a flag.  FIXME */
82       for (link = prev_chain; link != NULL; link = link->prev)
83         {
84           if (TREE_CODE_CLASS (TREE_CODE (link->decl)) != 'd')
85             pointer_type_breaks_cycle = 1;
86           if (link->decl == decl)
87             {
88               if (!pointer_type_breaks_cycle)
89                 {
90                   error_with_decl (decl, "cycle: `%s' depends on ...");
91                   cycle_error_print (prev_chain, decl);
92                   error_with_decl (decl, "  `%s'");
93                   return error_mark_node;
94                 }
95               /* There is a cycle, but it includes a pointer type,
96                  so we're OK.  However, we still have to continue
97                  the satisfy (for example in case this is a TYPE_DECL
98                  that points to a LANG_DECL).  The cycle-check for
99                  POINTER_TYPE/REFERENCE_TYPE should stop the recursion. */
100               break;
101             }
102         }
103
104       new_link.decl = decl;
105       new_link.prev = prev_chain;
106       chain = &new_link;
107     }
108
109   input_filename = DECL_SOURCE_FILE (decl);
110   lineno = DECL_SOURCE_LINE (decl);
111
112   switch ((enum chill_tree_code)TREE_CODE (decl))
113     {
114     case ALIAS_DECL:
115       if (!LOOKUP_ONLY && !DECL_POSTFIX_ALL(decl))
116         result = safe_satisfy_decl (DECL_ABSTRACT_ORIGIN (decl), chain);
117       break;
118     case BASED_DECL:
119       SATISFY (TREE_TYPE (decl));
120       SATISFY (DECL_ABSTRACT_ORIGIN (decl));
121       break;
122     case CONST_DECL:
123       SATISFY (TREE_TYPE (decl));
124       SATISFY (DECL_INITIAL (decl));
125       if (!LOOKUP_ONLY)
126         {
127           if (DECL_SIZE (decl) == 0)
128             {
129               tree init_expr = DECL_INITIAL (decl);
130               tree init_type;
131               tree specified_mode = TREE_TYPE (decl);
132
133               if (init_expr == NULL_TREE
134                   || TREE_CODE (init_expr) == ERROR_MARK)
135                 goto bad_const;
136               init_type = TREE_TYPE (init_expr);
137               if (specified_mode == NULL_TREE)
138                 {
139                   if (init_type == NULL_TREE)
140                     {
141                       check_have_mode (init_expr, "SYN without mode");
142                       goto bad_const;
143                     }
144                   TREE_TYPE (decl) = init_type;
145                   CH_DERIVED_FLAG (decl) = CH_DERIVED_FLAG (init_expr);
146                 }
147               else if (CH_IS_ASSOCIATION_MODE (specified_mode) ||
148                        CH_IS_ACCESS_MODE (specified_mode) || CH_IS_TEXT_MODE (specified_mode) ||
149                        CH_IS_BUFFER_MODE (specified_mode) || CH_IS_EVENT_MODE (specified_mode))
150                 {
151                   error ("SYN of this mode not allowed");
152                   goto bad_const;
153                 }
154               else if (!CH_COMPATIBLE (init_expr, specified_mode))
155                 {
156                   error ("mode of SYN incompatible with value");
157                   goto bad_const;
158                 } 
159               else if (discrete_type_p (specified_mode)
160                        && TREE_CODE (init_expr) == INTEGER_CST
161                        && (compare_int_csts (LT_EXPR, init_expr,
162                                              TYPE_MIN_VALUE (specified_mode))
163                            || compare_int_csts (GT_EXPR, init_expr,
164                                                 TYPE_MAX_VALUE(specified_mode))
165                            ))
166                 {
167                   error ("SYN value outside range of its mode");
168                   /* set an always-valid initial value to prevent 
169                      other errors. */
170                   DECL_INITIAL (decl) = TYPE_MIN_VALUE (specified_mode);
171                 }
172               else if (CH_STRING_TYPE_P (specified_mode) 
173                        && (init_type && CH_STRING_TYPE_P (init_type))
174                        && integer_zerop (string_assignment_condition (specified_mode, init_expr)))
175                 {
176                   error ("INIT string too large for mode");
177                   DECL_INITIAL (decl) = error_mark_node;
178                 }
179               else
180                 {
181                   struct ch_class class;
182                   class.mode = TREE_TYPE (decl);
183                   class.kind = CH_VALUE_CLASS;
184                   DECL_INITIAL (decl)
185                     = convert_to_class (class, DECL_INITIAL (decl));
186                 }
187               /* DECL_SIZE is set to prevent re-doing this stuff. */
188               DECL_SIZE (decl) = TYPE_SIZE (TREE_TYPE (decl));
189               DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (TREE_TYPE (decl));
190
191               if (! TREE_CONSTANT (DECL_INITIAL (decl))
192                   && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK)
193                 {
194                   error_with_decl (decl,
195                                    "value of %s is not a valid constant");
196                   DECL_INITIAL (decl) = error_mark_node;
197                 }
198             }
199           result = DECL_INITIAL (decl);
200         }
201       break;
202     bad_const:
203       DECL_INITIAL (decl) = error_mark_node;
204       TREE_TYPE (decl) = error_mark_node;
205       return error_mark_node;
206     case FUNCTION_DECL:
207       SATISFY (TREE_TYPE (decl));
208       if (CH_DECL_PROCESS (decl))
209         safe_satisfy_decl ((tree) DECL_TASKING_CODE_DECL (decl), prev_chain);
210       break;
211     case PARM_DECL:
212       SATISFY (TREE_TYPE (decl));
213       break;
214     /* RESULT_DECL doesn't need to be satisfied;  
215        it's only built internally in pass 2 */
216     case TYPE_DECL:
217       SATISFY (TREE_TYPE (decl));
218       if (CH_DECL_SIGNAL (decl))
219         safe_satisfy_decl ((tree) DECL_TASKING_CODE_DECL (decl), prev_chain);
220       if (!LOOKUP_ONLY)
221         {
222           if (TYPE_NAME (TREE_TYPE (decl)) == NULL_TREE)
223             TYPE_NAME (TREE_TYPE (decl)) = decl;
224           layout_decl (decl, 0);
225           if (CH_DECL_SIGNAL (decl) && CH_TYPE_NONVALUE_P (TREE_TYPE (decl)))
226             error ("mode with non-value property in signal definition");
227           result = TREE_TYPE (decl);
228         }
229       break;
230     case VAR_DECL:
231       SATISFY (TREE_TYPE (decl));
232       if (!LOOKUP_ONLY)
233         {
234           layout_decl (decl, 0);
235           if (TREE_READONLY (TREE_TYPE (decl)))
236             TREE_READONLY (decl) = 1;
237         }
238       break;
239     default:
240       ;
241     }
242
243   /* Now set the DECL_RTL, if needed. */
244   if (!LOOKUP_ONLY && DECL_RTL (decl) == 0
245       && (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == FUNCTION_DECL
246           || TREE_CODE (decl) == CONST_DECL))
247     {
248       if (TREE_CODE (decl) == FUNCTION_DECL && decl_function_context (decl))
249         make_function_rtl (decl);
250       else if (!TREE_STATIC (decl) && !DECL_EXTERNAL (decl))
251         expand_decl (decl);
252       else
253         { char * asm_name;
254           if (current_module == 0 || TREE_PUBLIC (decl)
255               || current_function_decl)
256             asm_name = NULL;
257           else
258             {
259               asm_name = (char*)
260                 alloca (IDENTIFIER_LENGTH (current_module->prefix_name)
261                         + IDENTIFIER_LENGTH (DECL_NAME (decl)) + 3);
262               sprintf (asm_name, "%s__%s",
263                        IDENTIFIER_POINTER (current_module->prefix_name),
264                        IDENTIFIER_POINTER (DECL_NAME (decl)));
265             }
266           make_decl_rtl (decl, asm_name, TREE_PUBLIC (decl));
267         }
268     }
269
270   input_filename = save_filename;
271   lineno = save_lineno;
272
273   return result;
274 }
275
276 tree
277 satisfy_decl (decl, lookup_only)
278      tree decl;
279      int lookup_only;
280 {
281   return safe_satisfy_decl (decl, lookup_only ? &dummy_chain : NULL);
282 }
283
284 static void
285 satisfy_list (exp, chain)
286      register tree exp;
287      struct decl_chain *chain;
288 {
289   for (; exp != NULL_TREE; exp = TREE_CHAIN (exp))
290     {
291       SATISFY (TREE_VALUE (exp));
292       SATISFY (TREE_PURPOSE (exp));
293     }
294 }
295
296 static void
297 satisfy_list_values (exp, chain)
298      register tree exp;
299      struct decl_chain *chain;
300 {
301   for (; exp != NULL_TREE; exp = TREE_CHAIN (exp))
302     {
303       SATISFY (TREE_VALUE (exp));
304     }
305 }
306
307 static tree
308 satisfy (exp, chain)
309      tree exp;
310      struct decl_chain *chain;
311 {
312   int arg_length;
313   int i;
314   tree decl;
315
316   if (exp == NULL_TREE)
317     return NULL_TREE;
318
319 #if 0
320   if (!UNSATISFIED (exp))
321     return exp;
322 #endif
323
324   switch (TREE_CODE_CLASS (TREE_CODE (exp)))
325     {
326     case 'd':
327       if (!LOOKUP_ONLY)
328         return safe_satisfy_decl (exp, chain);
329       break;
330     case 'r':
331     case 's':
332     case '<':
333     case 'e':
334       switch ((enum chill_tree_code)TREE_CODE (exp))
335         {
336         case REPLICATE_EXPR:
337           goto binary_op;
338         case TRUTH_NOT_EXPR:
339           goto unary_op;
340         case COMPONENT_REF:
341           SATISFY (TREE_OPERAND (exp, 0));
342           if (!LOOKUP_ONLY && TREE_TYPE (exp) == NULL_TREE)
343             return resolve_component_ref (exp);
344           return exp;
345         case CALL_EXPR:
346           SATISFY (TREE_OPERAND (exp, 0));
347           SATISFY (TREE_OPERAND (exp, 1));
348           if (!LOOKUP_ONLY && TREE_TYPE (exp) == NULL_TREE)
349             return build_generalized_call (TREE_OPERAND (exp, 0),
350                                            TREE_OPERAND (exp, 1));
351           return exp;
352         case CONSTRUCTOR:
353           { tree link = TREE_OPERAND (exp, 1);
354             int expand_needed = TREE_TYPE (exp)
355               && TREE_CODE_CLASS (TREE_CODE (TREE_TYPE (exp))) != 't';
356             for (; link != NULL_TREE; link = TREE_CHAIN (link))
357               {
358                 SATISFY (TREE_VALUE (link));
359                 if (!TUPLE_NAMED_FIELD (link))
360                   SATISFY (TREE_PURPOSE (link));
361               }
362             SATISFY (TREE_TYPE (exp));
363             if (expand_needed && !LOOKUP_ONLY)
364               {
365                 tree type = TREE_TYPE (exp);
366                 TREE_TYPE (exp) = NULL_TREE; /* To force expansion. */
367                 return chill_expand_tuple (type, exp);
368               }
369             return exp;
370           }
371         default:
372           ;
373         }
374
375       arg_length = TREE_CODE_LENGTH (TREE_CODE (exp));
376       for (i = 0; i < arg_length; i++)
377         SATISFY (TREE_OPERAND (exp, i));
378       return exp;
379     case '1':
380     unary_op:
381       SATISFY (TREE_OPERAND (exp, 0));
382       if ((enum chill_tree_code)TREE_CODE (exp) == PAREN_EXPR)
383         return TREE_OPERAND (exp, 0);
384       if (!LOOKUP_ONLY)
385         return finish_chill_unary_op (exp);
386       break;
387     case '2':
388     binary_op:
389       SATISFY (TREE_OPERAND (exp, 0));
390       SATISFY (TREE_OPERAND (exp, 1));
391       if (!LOOKUP_ONLY && TREE_CODE (exp) != RANGE_EXPR)
392         return finish_chill_binary_op (exp);
393       break;
394     case 'x':
395       switch ((enum chill_tree_code)TREE_CODE (exp))
396         {
397         case IDENTIFIER_NODE:
398           decl = lookup_name (exp);
399           if (decl == NULL)
400             {
401               if (LOOKUP_ONLY)
402                 return exp;
403               error ("undeclared identifier `%s'", IDENTIFIER_POINTER (exp));
404               return error_mark_node;
405             }
406           if (LOOKUP_ONLY)
407             return decl;
408           return safe_satisfy_decl (decl, chain);
409         case TREE_LIST:
410           satisfy_list (exp, chain);
411           break;
412         default:
413           ;
414         }
415       break;
416     case 't':
417       /* If TYPE_SIZE is non-NULL, exp and its subfields has already been
418          satified and laid out.  The exception is pointer and reference types,
419          which we layout before we lay out their TREE_TYPE. */
420       if (TYPE_SIZE (exp) && TREE_CODE (exp) != POINTER_TYPE
421           && TREE_CODE (exp) != REFERENCE_TYPE)
422         return exp;
423       if (TYPE_MAIN_VARIANT (exp) != exp)
424         SATISFY (TYPE_MAIN_VARIANT (exp));
425       switch ((enum chill_tree_code)TREE_CODE (exp))
426         {
427         case LANG_TYPE:
428           {
429             tree d = TYPE_DOMAIN (exp);
430             tree t = satisfy (TREE_TYPE (exp), chain);
431             SATISFY (d);
432             /* It is possible that one of the above satisfy calls recursively
433                caused exp to be satisfied, in which case we're done. */
434             if (TREE_CODE (exp) != LANG_TYPE)
435               return exp;
436             TREE_TYPE (exp) = t;
437             TYPE_DOMAIN (exp) = d;
438             if (!LOOKUP_ONLY)
439               exp = smash_dummy_type (exp);
440           }
441           break;
442         case ARRAY_TYPE:
443           SATISFY (TREE_TYPE (exp));
444           SATISFY (TYPE_DOMAIN (exp));
445           SATISFY (TYPE_ATTRIBUTES (exp));
446           if (!LOOKUP_ONLY)
447             CH_TYPE_NONVALUE_P (exp) = CH_TYPE_NONVALUE_P (TREE_TYPE (exp));
448           if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
449             exp = layout_chill_array_type (exp);
450           break;
451         case FUNCTION_TYPE:
452           SATISFY (TREE_TYPE (exp));
453           if (TREE_CODE_CLASS (TREE_CODE (TREE_TYPE (exp))) != 't'
454               && !LOOKUP_ONLY && TREE_CODE (TREE_TYPE (exp)) != ERROR_MARK)
455             {
456               error ("RETURNS spec with invalid mode");
457               TREE_TYPE (exp) = error_mark_node;
458             }
459           satisfy_list_values (TYPE_ARG_TYPES (exp), chain);
460           if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
461             layout_type (exp);
462           break;
463         case ENUMERAL_TYPE:
464           if (TYPE_SIZE (exp) == NULL_TREE && !LOOKUP_ONLY)
465             { tree pair;
466               /* FIXME:  Should this use satisfy_decl? */
467               for (pair = TYPE_VALUES (exp); pair; pair = TREE_CHAIN (pair))
468                 SATISFY (DECL_INITIAL (TREE_VALUE (pair)));
469               layout_enum (exp);
470             }
471           break;
472         case INTEGER_TYPE:
473           SATISFY (TYPE_MIN_VALUE (exp));
474           SATISFY (TYPE_MAX_VALUE (exp));
475           if (TREE_TYPE (exp) != NULL_TREE)
476             { /* A range type */
477               if (TREE_TYPE (exp) != ridpointers[(int) RID_RANGE]
478                   && TREE_TYPE (exp) != ridpointers[(int) RID_BIN]
479                   && TREE_TYPE (exp) != string_index_type_dummy)
480                 SATISFY (TREE_TYPE (exp));
481               if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
482                 exp = layout_chill_range_type (exp, 1);
483             }
484           break;
485         case POINTER_TYPE:
486         case REFERENCE_TYPE:
487           if (LOOKUP_ONLY)
488             SATISFY (TREE_TYPE (exp));
489           else
490             {
491               struct decl_chain *link;
492               int already_seen = 0;
493               for (link = chain; ; link = link->prev)
494                 {
495                   if (link == NULL)
496                     {   
497                       struct decl_chain new_link;
498                       new_link.decl = exp;
499                       new_link.prev = chain;
500                       TREE_TYPE (exp) = satisfy (TREE_TYPE (exp), &new_link);
501                       break;
502                     }
503                   else if (link->decl == exp)
504                     {
505                       already_seen = 1;
506                       break;
507                     }
508                 }
509               if (!TYPE_SIZE (exp))
510                 {
511                   layout_type (exp);
512                   if (TREE_CODE (exp) == REFERENCE_TYPE)
513                     CH_NOVELTY (exp) = CH_NOVELTY (TREE_TYPE (exp));
514                   if (! already_seen)
515                     {
516                       tree valtype = TREE_TYPE (exp);
517                       if (TREE_CODE_CLASS (TREE_CODE (valtype)) != 't')
518                         {
519                           if (TREE_CODE (valtype) != ERROR_MARK)
520                             error ("operand to REF is not a mode");
521                           TREE_TYPE (exp) = error_mark_node;
522                           return error_mark_node;
523                         }
524                       else if (TREE_CODE (exp) == POINTER_TYPE
525                                && TYPE_POINTER_TO (valtype) == NULL)
526                         TYPE_POINTER_TO (valtype) = exp;
527                     }
528                 }
529             }
530           break;
531         case RECORD_TYPE:
532           {
533             /* FIXME: detected errors in here will be printed as
534                often as this sequence runs. Find another way or
535                place to print the errors. */
536             /* if we have an ACCESS or TEXT mode we have to set
537                maximum_field_alignment to 0 to fit with runtime
538                system, even when we compile with -fpack. */
539             unsigned int save_maximum_field_alignment = maximum_field_alignment;
540
541             if (CH_IS_ACCESS_MODE (exp) || CH_IS_TEXT_MODE (exp))
542               maximum_field_alignment = 0;
543
544             for (decl = TYPE_FIELDS (exp); decl; decl = TREE_CHAIN (decl))
545               {
546                 SATISFY (TREE_TYPE (decl));
547                 if (!LOOKUP_ONLY)
548                   {
549                     /* if we have a UNION_TYPE here (variant structure), check for
550                        non-value mode in it. This is not allowed (Z.200/pg. 33) */
551                     if (TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE &&
552                         CH_TYPE_NONVALUE_P (TREE_TYPE (decl)))
553                       {
554                         error ("field with non-value mode in variant structure not allowed");
555                         TREE_TYPE (decl) = error_mark_node;
556                       }
557                     /* RECORD_TYPE gets the non-value property if one of the
558                        fields has the non-value property */
559                     CH_TYPE_NONVALUE_P (exp) |= CH_TYPE_NONVALUE_P (TREE_TYPE (decl));
560                   }
561                 if (TREE_CODE (decl) == CONST_DECL)
562                   {
563                     SATISFY (DECL_INITIAL (decl));
564                     if (!LOOKUP_ONLY)
565                       {
566                         if (CH_IS_BUFFER_MODE (exp) || CH_IS_EVENT_MODE (exp))
567                           DECL_INITIAL (decl)
568                             = check_queue_size (DECL_INITIAL (decl));
569                         else if (CH_IS_TEXT_MODE (exp) &&
570                                  DECL_NAME (decl) == get_identifier ("__textlength"))
571                           DECL_INITIAL (decl)
572                             = check_text_length (DECL_INITIAL (decl));
573                       }
574                   }
575                 else if (TREE_CODE (decl) == FIELD_DECL)
576                   {
577                     SATISFY (DECL_INITIAL (decl));
578                   }
579               }
580             satisfy_list (TYPE_TAG_VALUES (exp), chain);
581             if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
582               exp = layout_chill_struct_type (exp);
583             maximum_field_alignment = save_maximum_field_alignment;
584
585             /* perform some checks on nonvalue modes, they are record_mode's */
586             if (!LOOKUP_ONLY)
587               {
588                 if (CH_IS_BUFFER_MODE (exp))
589                   {
590                     tree elemmode = buffer_element_mode (exp);
591                     if (elemmode != NULL_TREE && CH_TYPE_NONVALUE_P (elemmode))
592                       {
593                         error ("buffer element mode must not have non-value property");
594                         invalidate_buffer_element_mode (exp);
595                       }
596                   }
597                 else if (CH_IS_ACCESS_MODE (exp))
598                   {
599                     tree recordmode = access_recordmode (exp);
600                     if (recordmode != NULL_TREE && CH_TYPE_NONVALUE_P (recordmode))
601                       {
602                         error ("recordmode must not have the non-value property");
603                         invalidate_access_recordmode (exp);
604                       }
605                   }
606               }
607           }
608           break;
609         case SET_TYPE:
610           SATISFY (TYPE_DOMAIN (exp));
611           if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
612             exp = layout_powerset_type (exp);
613           break;
614         case UNION_TYPE:
615           for (decl = TYPE_FIELDS (exp); decl; decl = TREE_CHAIN (decl))
616             {
617               SATISFY (TREE_TYPE (decl));
618               if (!LOOKUP_ONLY)
619                 CH_TYPE_NONVALUE_P (exp) |= CH_TYPE_NONVALUE_P (TREE_TYPE (decl));
620             }
621           if (!TYPE_SIZE (exp)  && !LOOKUP_ONLY)
622             exp = layout_chill_variants (exp);
623           break;
624         default:
625           ;
626         }
627     }
628   return exp;
629 }