gcc/ch/xtypeck.c

   1 /* Copyright (C) 1992, 93, 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 /* start-sanitize-chill */
  47       case TRUTH_ANDIF_EXPR:
  48       case TRUTH_ORIF_EXPR:
  49       case COMPOUND_EXPR:
  50 /* end-sanitize-chill */
  51         x = TREE_OPERAND (x, 0);
  52         break;
  53 /* start-sanitize-chill */
  54
  55       case COND_EXPR:
  56         return mark_addressable (TREE_OPERAND (x, 1))
  57           & mark_addressable (TREE_OPERAND (x, 2));
  58 /* end-sanitize-chill */
  59
  60       case CONSTRUCTOR:
  61         TREE_ADDRESSABLE (x) = 1;
  62         return 1;
  63
  64       case VAR_DECL:
  65       case CONST_DECL:
  66       case PARM_DECL:
  67       case RESULT_DECL:
  68         if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x)
  69             && DECL_NONLOCAL (x))
  70           {
  71             if (TREE_PUBLIC (x))
  72               {
  73                 error ("global register variable `%s' used in nested function",
  74                        IDENTIFIER_POINTER (DECL_NAME (x)));
  75                 return 0;
  76               }
  77             pedwarn ("register variable `%s' used in nested function",
  78                      IDENTIFIER_POINTER (DECL_NAME (x)));
  79           }
  80         else if (DECL_REGISTER (x) && !TREE_ADDRESSABLE (x))
  81           {
  82             if (TREE_PUBLIC (x))
  83               {
  84                 error ("address of global register variable `%s' requested",
  85                        IDENTIFIER_POINTER (DECL_NAME (x)));
  86                 return 0;
  87               }
  88
  89             /* If we are making this addressable due to its having
  90                volatile components, give a different error message.  Also
  91                handle the case of an unnamed parameter by not trying
  92                to give the name.  */
  93
  94             else if (C_TYPE_FIELDS_VOLATILE (TREE_TYPE (x)))
  95               {
  96                 error ("cannot put object with volatile field into register");
  97                 return 0;
  98               }
  99
 100             pedwarn ("address of register variable `%s' requested",
 101                      IDENTIFIER_POINTER (DECL_NAME (x)));
 102           }
 103         put_var_into_stack (x);
 104
 105         /* drops in */
 106       case FUNCTION_DECL:
 107         TREE_ADDRESSABLE (x) = 1;
 108 #if 0  /* poplevel deals with this now.  */
 109         if (DECL_CONTEXT (x) == 0)
 110           TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (x)) = 1;
 111 #endif
 112
 113       default:
 114         return 1;
 115     }
 116 }
 117
 118 /* Return an unsigned type the same as TYPE in other respects.  */
 119
 120 tree
 121 unsigned_type (type)
 122      tree type;
 123 {
 124   tree type1 = TYPE_MAIN_VARIANT (type);
 125   if (type1 == signed_char_type_node || type1 == char_type_node)
 126     return unsigned_char_type_node;
 127   if (type1 == integer_type_node)
 128     return unsigned_type_node;
 129   if (type1 == short_integer_type_node)
 130     return short_unsigned_type_node;
 131   if (type1 == long_integer_type_node)
 132     return long_unsigned_type_node;
 133   if (type1 == long_long_integer_type_node)
 134     return long_long_unsigned_type_node;
 135   return type;
 136 }
 137
 138 /* Return a signed type the same as TYPE in other respects.  */
 139
 140 tree
 141 signed_type (type)
 142      tree type;
 143 {
 144   tree type1 = TYPE_MAIN_VARIANT (type);
 145   if (type1 == unsigned_char_type_node || type1 == char_type_node)
 146     return signed_char_type_node;
 147   if (type1 == unsigned_type_node)
 148     return integer_type_node;
 149   if (type1 == short_unsigned_type_node)
 150     return short_integer_type_node;
 151   if (type1 == long_unsigned_type_node)
 152     return long_integer_type_node;
 153   if (type1 == long_long_unsigned_type_node)
 154     return long_long_integer_type_node;
 155   return type;
 156 }
 157
 158 /* Return a type the same as TYPE except unsigned or
 159    signed according to UNSIGNEDP.  */
 160
 161 tree
 162 signed_or_unsigned_type (unsignedp, type)
 163      int unsignedp;
 164      tree type;
 165 {
 166   if (! INTEGRAL_TYPE_P (type))
 167     return type;
 168   if (TYPE_PRECISION (type) == TYPE_PRECISION (signed_char_type_node))
 169     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 170   if (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
 171     return unsignedp ? unsigned_type_node : integer_type_node;
 172   if (TYPE_PRECISION (type) == TYPE_PRECISION (short_integer_type_node))
 173     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 174   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_integer_type_node))
 175     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 176   if (TYPE_PRECISION (type) == TYPE_PRECISION (long_long_integer_type_node))
 177     return (unsignedp ? long_long_unsigned_type_node
 178             : long_long_integer_type_node);
 179   return type;
 180 }
 181
 182 extern tree intHI_type_node;
 183 extern tree intSI_type_node;
 184 extern tree intDI_type_node;
 185
 186 extern tree unsigned_intHI_type_node;
 187 extern tree unsigned_intSI_type_node;
 188 extern tree unsigned_intDI_type_node;
 189
 190 /* Return an integer type with BITS bits of precision,
 191    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
 192
 193 tree
 194 type_for_size (bits, unsignedp)
 195      unsigned bits;
 196      int unsignedp;
 197 {
 198   if (bits == TYPE_PRECISION (signed_char_type_node))
 199     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 200
 201   if (bits == TYPE_PRECISION (short_integer_type_node))
 202     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 203
 204   if (bits == TYPE_PRECISION (integer_type_node))
 205     return unsignedp ? unsigned_type_node : integer_type_node;
 206
 207   if (bits == TYPE_PRECISION (long_integer_type_node))
 208     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 209
 210   if (bits == TYPE_PRECISION (long_long_integer_type_node))
 211     return (unsignedp ? long_long_unsigned_type_node
 212             : long_long_integer_type_node);
 213
 214   if (bits <= TYPE_PRECISION (intHI_type_node))
 215     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 216
 217   if (bits <= TYPE_PRECISION (intSI_type_node))
 218     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 219
 220   if (bits <= TYPE_PRECISION (intDI_type_node))
 221     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 222
 223   return 0;
 224 }
 225
 226 /* Return a data type that has machine mode MODE.
 227    If the mode is an integer,
 228    then UNSIGNEDP selects between signed and unsigned types.  */
 229
 230 tree
 231 type_for_mode (mode, unsignedp)
 232      enum machine_mode mode;
 233      int unsignedp;
 234 {
 235   if (mode == TYPE_MODE (signed_char_type_node))
 236     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
 237
 238   if (mode == TYPE_MODE (short_integer_type_node))
 239     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
 240
 241   if (mode == TYPE_MODE (integer_type_node))
 242     return unsignedp ? unsigned_type_node : integer_type_node;
 243
 244   if (mode == TYPE_MODE (long_integer_type_node))
 245     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
 246
 247   if (mode == TYPE_MODE (long_long_integer_type_node))
 248     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
 249
 250   if (mode == TYPE_MODE (intHI_type_node))
 251     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
 252
 253   if (mode == TYPE_MODE (intSI_type_node))
 254     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
 255
 256   if (mode == TYPE_MODE (intDI_type_node))
 257     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
 258
 259   if (mode == TYPE_MODE (float_type_node))
 260     return float_type_node;
 261
 262   if (mode == TYPE_MODE (double_type_node))
 263     return double_type_node;
 264
 265   if (mode == TYPE_MODE (long_double_type_node))
 266     return long_double_type_node;
 267
 268   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
 269     return build_pointer_type (char_type_node);
 270
 271   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
 272     return build_pointer_type (integer_type_node);
 273
 274   return 0;
 275 }
 276
 277 tree
 278 truthvalue_conversion (expr)
 279      tree expr;
 280 {
 281   return chill_truthvalue_conversion (expr);
 282 }
 283 #endif