118334Speter/* Build expressions with type checking for C compiler. 2169689Skan Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4169689Skan Free Software Foundation, Inc. 518334Speter 690075SobrienThis file is part of GCC. 718334Speter 890075SobrienGCC is free software; you can redistribute it and/or modify it under 990075Sobrienthe terms of the GNU General Public License as published by the Free 1090075SobrienSoftware Foundation; either version 2, or (at your option) any later 1190075Sobrienversion. 1218334Speter 1390075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690075Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169689Skan02110-1301, USA. */ 2218334Speter 2318334Speter 2418334Speter/* This file is part of the C front end. 2518334Speter It contains routines to build C expressions given their operands, 2618334Speter including computing the types of the result, C-specific error checks, 27169689Skan and some optimization. */ 2818334Speter 2918334Speter#include "config.h" 3050397Sobrien#include "system.h" 31132718Skan#include "coretypes.h" 32132718Skan#include "tm.h" 3390075Sobrien#include "rtl.h" 3418334Speter#include "tree.h" 35169689Skan#include "langhooks.h" 3618334Speter#include "c-tree.h" 3790075Sobrien#include "tm_p.h" 3818334Speter#include "flags.h" 3918334Speter#include "output.h" 4050397Sobrien#include "expr.h" 4150397Sobrien#include "toplev.h" 4252284Sobrien#include "intl.h" 4390075Sobrien#include "ggc.h" 4490075Sobrien#include "target.h" 45169689Skan#include "tree-iterator.h" 46169689Skan#include "tree-gimple.h" 47169689Skan#include "tree-flow.h" 4818334Speter 49169689Skan/* Possible cases of implicit bad conversions. Used to select 50169689Skan diagnostic messages in convert_for_assignment. */ 51169689Skanenum impl_conv { 52169689Skan ic_argpass, 53169689Skan ic_argpass_nonproto, 54169689Skan ic_assign, 55169689Skan ic_init, 56169689Skan ic_return 57169689Skan}; 58169689Skan 59169689Skan/* The level of nesting inside "__alignof__". */ 60169689Skanint in_alignof; 61169689Skan 62169689Skan/* The level of nesting inside "sizeof". */ 63169689Skanint in_sizeof; 64169689Skan 65169689Skan/* The level of nesting inside "typeof". */ 66169689Skanint in_typeof; 67169689Skan 68169689Skanstruct c_label_context_se *label_context_stack_se; 69169689Skanstruct c_label_context_vm *label_context_stack_vm; 70169689Skan 7118334Speter/* Nonzero if we've already printed a "missing braces around initializer" 7218334Speter message within this initializer. */ 7318334Speterstatic int missing_braces_mentioned; 7418334Speter 75132718Skanstatic int require_constant_value; 76132718Skanstatic int require_constant_elements; 7790075Sobrien 78260311Spfg/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 79260311Spfgstatic bool types_are_block_compatible (tree lhptee, tree rhptee); 80260311Spfgstatic tree build_block_call (tree, tree, tree); 81260311Spfg/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 82169689Skanstatic bool null_pointer_constant_p (tree); 83132718Skanstatic tree qualify_type (tree, tree); 84169689Skanstatic int tagged_types_tu_compatible_p (tree, tree); 85169689Skanstatic int comp_target_types (tree, tree); 86169689Skanstatic int function_types_compatible_p (tree, tree); 87169689Skanstatic int type_lists_compatible_p (tree, tree); 88132718Skanstatic tree decl_constant_value_for_broken_optimization (tree); 89132718Skanstatic tree lookup_field (tree, tree); 90132718Skanstatic tree convert_arguments (tree, tree, tree, tree); 91132718Skanstatic tree pointer_diff (tree, tree); 92169689Skanstatic tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree, 93132718Skan int); 94132718Skanstatic tree valid_compound_expr_initializer (tree, tree); 95132718Skanstatic void push_string (const char *); 96132718Skanstatic void push_member_name (tree); 97132718Skanstatic int spelling_length (void); 98132718Skanstatic char *print_spelling (char *); 99132718Skanstatic void warning_init (const char *); 100169689Skanstatic tree digest_init (tree, tree, bool, int); 101169689Skanstatic void output_init_element (tree, bool, tree, tree, int); 102132718Skanstatic void output_pending_init_elements (int); 103132718Skanstatic int set_designator (int); 104132718Skanstatic void push_range_stack (tree); 105132718Skanstatic void add_pending_init (tree, tree); 106132718Skanstatic void set_nonincremental_init (void); 107132718Skanstatic void set_nonincremental_init_from_string (tree); 108132718Skanstatic tree find_init_member (tree); 109169689Skanstatic void readonly_error (tree, enum lvalue_use); 110169689Skanstatic int lvalue_or_else (tree, enum lvalue_use); 111169689Skanstatic int lvalue_p (tree); 112169689Skanstatic void record_maybe_used_decl (tree); 113169689Skanstatic int comptypes_internal (tree, tree); 11418334Speter 115169689Skan/* Return true if EXP is a null pointer constant, false otherwise. */ 116169689Skan 117169689Skanstatic bool 118169689Skannull_pointer_constant_p (tree expr) 119169689Skan{ 120169689Skan /* This should really operate on c_expr structures, but they aren't 121169689Skan yet available everywhere required. */ 122169689Skan tree type = TREE_TYPE (expr); 123169689Skan return (TREE_CODE (expr) == INTEGER_CST 124169689Skan && !TREE_CONSTANT_OVERFLOW (expr) 125169689Skan && integer_zerop (expr) 126169689Skan && (INTEGRAL_TYPE_P (type) 127169689Skan || (TREE_CODE (type) == POINTER_TYPE 128169689Skan && VOID_TYPE_P (TREE_TYPE (type)) 129169689Skan && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))); 130169689Skan} 131169689Skan/* This is a cache to hold if two types are compatible or not. */ 132169689Skan 133169689Skanstruct tagged_tu_seen_cache { 134169689Skan const struct tagged_tu_seen_cache * next; 135169689Skan tree t1; 136169689Skan tree t2; 137169689Skan /* The return value of tagged_types_tu_compatible_p if we had seen 138169689Skan these two types already. */ 139169689Skan int val; 140169689Skan}; 141169689Skan 142169689Skanstatic const struct tagged_tu_seen_cache * tagged_tu_seen_base; 143169689Skanstatic void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *); 144169689Skan 14518334Speter/* Do `exp = require_complete_type (exp);' to make sure exp 14618334Speter does not have an incomplete type. (That includes void types.) */ 14718334Speter 14818334Spetertree 149132718Skanrequire_complete_type (tree value) 15018334Speter{ 15118334Speter tree type = TREE_TYPE (value); 15218334Speter 15390075Sobrien if (value == error_mark_node || type == error_mark_node) 15452284Sobrien return error_mark_node; 15552284Sobrien 15618334Speter /* First, detect a valid value with a complete type. */ 15790075Sobrien if (COMPLETE_TYPE_P (type)) 15818334Speter return value; 15918334Speter 160117395Skan c_incomplete_type_error (value, type); 16118334Speter return error_mark_node; 16218334Speter} 16318334Speter 16418334Speter/* Print an error message for invalid use of an incomplete type. 16518334Speter VALUE is the expression that was used (or 0 if that isn't known) 16618334Speter and TYPE is the type that was invalid. */ 16718334Speter 16818334Spetervoid 169132718Skanc_incomplete_type_error (tree value, tree type) 17018334Speter{ 17152284Sobrien const char *type_code_string; 17218334Speter 17318334Speter /* Avoid duplicate error message. */ 17418334Speter if (TREE_CODE (type) == ERROR_MARK) 17518334Speter return; 17618334Speter 17718334Speter if (value != 0 && (TREE_CODE (value) == VAR_DECL 17818334Speter || TREE_CODE (value) == PARM_DECL)) 179169689Skan error ("%qD has an incomplete type", value); 18018334Speter else 18118334Speter { 18218334Speter retry: 18318334Speter /* We must print an error message. Be clever about what it says. */ 18418334Speter 18518334Speter switch (TREE_CODE (type)) 18618334Speter { 18718334Speter case RECORD_TYPE: 18852284Sobrien type_code_string = "struct"; 18918334Speter break; 19018334Speter 19118334Speter case UNION_TYPE: 19252284Sobrien type_code_string = "union"; 19318334Speter break; 19418334Speter 19518334Speter case ENUMERAL_TYPE: 19652284Sobrien type_code_string = "enum"; 19718334Speter break; 19818334Speter 19918334Speter case VOID_TYPE: 20018334Speter error ("invalid use of void expression"); 20118334Speter return; 20218334Speter 20318334Speter case ARRAY_TYPE: 20418334Speter if (TYPE_DOMAIN (type)) 20518334Speter { 20696263Sobrien if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL) 20796263Sobrien { 20896263Sobrien error ("invalid use of flexible array member"); 20996263Sobrien return; 21096263Sobrien } 21118334Speter type = TREE_TYPE (type); 21218334Speter goto retry; 21318334Speter } 21418334Speter error ("invalid use of array with unspecified bounds"); 21518334Speter return; 21618334Speter 21718334Speter default: 218169689Skan gcc_unreachable (); 21918334Speter } 22018334Speter 22118334Speter if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 222169689Skan error ("invalid use of undefined type %<%s %E%>", 223169689Skan type_code_string, TYPE_NAME (type)); 22418334Speter else 22518334Speter /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 226169689Skan error ("invalid use of incomplete typedef %qD", TYPE_NAME (type)); 22718334Speter } 22818334Speter} 22918334Speter 230117395Skan/* Given a type, apply default promotions wrt unnamed function 231117395Skan arguments and return the new type. */ 232117395Skan 233117395Skantree 234132718Skanc_type_promotes_to (tree type) 235117395Skan{ 236117395Skan if (TYPE_MAIN_VARIANT (type) == float_type_node) 237117395Skan return double_type_node; 238117395Skan 239117395Skan if (c_promoting_integer_type_p (type)) 240117395Skan { 241117395Skan /* Preserve unsignedness if not really getting any wider. */ 242169689Skan if (TYPE_UNSIGNED (type) 243169689Skan && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))) 244169689Skan return unsigned_type_node; 245117395Skan return integer_type_node; 246117395Skan } 247117395Skan 248117395Skan return type; 249117395Skan} 250117395Skan 25118334Speter/* Return a variant of TYPE which has all the type qualifiers of LIKE 25218334Speter as well as those of TYPE. */ 25318334Speter 25418334Speterstatic tree 255132718Skanqualify_type (tree type, tree like) 25618334Speter{ 257132718Skan return c_build_qualified_type (type, 25852750Sobrien TYPE_QUALS (type) | TYPE_QUALS (like)); 25918334Speter} 260169689Skan 261169689Skan/* Return true iff the given tree T is a variable length array. */ 262169689Skan 263169689Skanbool 264169689Skanc_vla_type_p (tree t) 265169689Skan{ 266169689Skan if (TREE_CODE (t) == ARRAY_TYPE 267169689Skan && C_TYPE_VARIABLE_SIZE (t)) 268169689Skan return true; 269169689Skan return false; 270169689Skan} 27118334Speter 272169689Skan/* Return the composite type of two compatible types. 27318334Speter 274169689Skan We assume that comptypes has already been done and returned 275169689Skan nonzero; if that isn't so, this may crash. In particular, we 276169689Skan assume that qualifiers match. */ 27718334Speter 27818334Spetertree 279169689Skancomposite_type (tree t1, tree t2) 28018334Speter{ 28190075Sobrien enum tree_code code1; 28290075Sobrien enum tree_code code2; 28318334Speter tree attributes; 28418334Speter 28518334Speter /* Save time if the two types are the same. */ 28618334Speter 28718334Speter if (t1 == t2) return t1; 28818334Speter 28918334Speter /* If one type is nonsense, use the other. */ 29018334Speter if (t1 == error_mark_node) 29118334Speter return t2; 29218334Speter if (t2 == error_mark_node) 29318334Speter return t1; 29418334Speter 295169689Skan code1 = TREE_CODE (t1); 296169689Skan code2 = TREE_CODE (t2); 297169689Skan 29850397Sobrien /* Merge the attributes. */ 299169689Skan attributes = targetm.merge_type_attributes (t1, t2); 30018334Speter 301169689Skan /* If one is an enumerated type and the other is the compatible 302169689Skan integer type, the composite type might be either of the two 303169689Skan (DR#013 question 3). For consistency, use the enumerated type as 304169689Skan the composite type. */ 30518334Speter 306169689Skan if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE) 307169689Skan return t1; 308169689Skan if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE) 309169689Skan return t2; 31018334Speter 311169689Skan gcc_assert (code1 == code2); 31218334Speter 31318334Speter switch (code1) 31418334Speter { 31518334Speter case POINTER_TYPE: 316169689Skan /* For two pointers, do this recursively on the target type. */ 31718334Speter { 31852284Sobrien tree pointed_to_1 = TREE_TYPE (t1); 31952284Sobrien tree pointed_to_2 = TREE_TYPE (t2); 320169689Skan tree target = composite_type (pointed_to_1, pointed_to_2); 321169689Skan t1 = build_pointer_type (target); 322169689Skan t1 = build_type_attribute_variant (t1, attributes); 323169689Skan return qualify_type (t1, t2); 32418334Speter } 32518334Speter 32618334Speter case ARRAY_TYPE: 32718334Speter { 328169689Skan tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 329169689Skan int quals; 330169689Skan tree unqual_elt; 331169689Skan tree d1 = TYPE_DOMAIN (t1); 332169689Skan tree d2 = TYPE_DOMAIN (t2); 333169689Skan bool d1_variable, d2_variable; 334169689Skan bool d1_zero, d2_zero; 335169689Skan 336169689Skan /* We should not have any type quals on arrays at all. */ 337169689Skan gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2)); 338169689Skan 339169689Skan d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1); 340169689Skan d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2); 341169689Skan 342169689Skan d1_variable = (!d1_zero 343169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 344169689Skan || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 345169689Skan d2_variable = (!d2_zero 346169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 347169689Skan || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 348169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 349169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 350169689Skan 35118334Speter /* Save space: see if the result is identical to one of the args. */ 352169689Skan if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1) 353169689Skan && (d2_variable || d2_zero || !d1_variable)) 35418334Speter return build_type_attribute_variant (t1, attributes); 355169689Skan if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2) 356169689Skan && (d1_variable || d1_zero || !d2_variable)) 35718334Speter return build_type_attribute_variant (t2, attributes); 358169689Skan 359169689Skan if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 360169689Skan return build_type_attribute_variant (t1, attributes); 361169689Skan if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 362169689Skan return build_type_attribute_variant (t2, attributes); 363169689Skan 364169689Skan /* Merge the element types, and have a size if either arg has 365169689Skan one. We may have qualifiers on the element types. To set 366169689Skan up TYPE_MAIN_VARIANT correctly, we need to form the 367169689Skan composite of the unqualified types and add the qualifiers 368169689Skan back at the end. */ 369169689Skan quals = TYPE_QUALS (strip_array_types (elt)); 370169689Skan unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED); 371169689Skan t1 = build_array_type (unqual_elt, 372169689Skan TYPE_DOMAIN ((TYPE_DOMAIN (t1) 373169689Skan && (d2_variable 374169689Skan || d2_zero 375169689Skan || !d1_variable)) 376169689Skan ? t1 377169689Skan : t2)); 378169689Skan t1 = c_build_qualified_type (t1, quals); 37918334Speter return build_type_attribute_variant (t1, attributes); 38018334Speter } 38118334Speter 382169689Skan case ENUMERAL_TYPE: 383169689Skan case RECORD_TYPE: 384169689Skan case UNION_TYPE: 385169689Skan if (attributes != NULL) 386169689Skan { 387169689Skan /* Try harder not to create a new aggregate type. */ 388169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes)) 389169689Skan return t1; 390169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes)) 391169689Skan return t2; 392169689Skan } 393169689Skan return build_type_attribute_variant (t1, attributes); 394169689Skan 39518334Speter case FUNCTION_TYPE: 39618334Speter /* Function types: prefer the one that specified arg types. 39718334Speter If both do, merge the arg types. Also merge the return types. */ 39818334Speter { 399169689Skan tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 40018334Speter tree p1 = TYPE_ARG_TYPES (t1); 40118334Speter tree p2 = TYPE_ARG_TYPES (t2); 40218334Speter int len; 40318334Speter tree newargs, n; 40418334Speter int i; 40518334Speter 40618334Speter /* Save space: see if the result is identical to one of the args. */ 407169689Skan if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2)) 40818334Speter return build_type_attribute_variant (t1, attributes); 409169689Skan if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1)) 41018334Speter return build_type_attribute_variant (t2, attributes); 41118334Speter 41218334Speter /* Simple way if one arg fails to specify argument types. */ 41318334Speter if (TYPE_ARG_TYPES (t1) == 0) 41418334Speter { 415169689Skan t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2)); 416169689Skan t1 = build_type_attribute_variant (t1, attributes); 417169689Skan return qualify_type (t1, t2); 41818334Speter } 41918334Speter if (TYPE_ARG_TYPES (t2) == 0) 42018334Speter { 42118334Speter t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1)); 422169689Skan t1 = build_type_attribute_variant (t1, attributes); 423169689Skan return qualify_type (t1, t2); 42418334Speter } 42518334Speter 42618334Speter /* If both args specify argument types, we must merge the two 42718334Speter lists, argument by argument. */ 428169689Skan /* Tell global_bindings_p to return false so that variable_size 429169689Skan doesn't die on VLAs in parameter types. */ 430169689Skan c_override_global_bindings_to_false = true; 43118334Speter 43218334Speter len = list_length (p1); 43318334Speter newargs = 0; 43418334Speter 43518334Speter for (i = 0; i < len; i++) 43618334Speter newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 43718334Speter 43818334Speter n = newargs; 43918334Speter 44018334Speter for (; p1; 44118334Speter p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) 44218334Speter { 44318334Speter /* A null type means arg type is not specified. 44418334Speter Take whatever the other function type has. */ 44518334Speter if (TREE_VALUE (p1) == 0) 44618334Speter { 44718334Speter TREE_VALUE (n) = TREE_VALUE (p2); 44818334Speter goto parm_done; 44918334Speter } 45018334Speter if (TREE_VALUE (p2) == 0) 45118334Speter { 45218334Speter TREE_VALUE (n) = TREE_VALUE (p1); 45318334Speter goto parm_done; 45418334Speter } 455132718Skan 45618334Speter /* Given wait (union {union wait *u; int *i} *) 45718334Speter and wait (union wait *), 45818334Speter prefer union wait * as type of parm. */ 45918334Speter if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE 46018334Speter && TREE_VALUE (p1) != TREE_VALUE (p2)) 46118334Speter { 46218334Speter tree memb; 463169689Skan tree mv2 = TREE_VALUE (p2); 464169689Skan if (mv2 && mv2 != error_mark_node 465169689Skan && TREE_CODE (mv2) != ARRAY_TYPE) 466169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 46718334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p1)); 46818334Speter memb; memb = TREE_CHAIN (memb)) 469169689Skan { 470169689Skan tree mv3 = TREE_TYPE (memb); 471169689Skan if (mv3 && mv3 != error_mark_node 472169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 473169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 474169689Skan if (comptypes (mv3, mv2)) 475169689Skan { 476169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 477169689Skan TREE_VALUE (p2)); 478169689Skan if (pedantic) 479169689Skan pedwarn ("function types not truly compatible in ISO C"); 480169689Skan goto parm_done; 481169689Skan } 482169689Skan } 48318334Speter } 48418334Speter if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE 48518334Speter && TREE_VALUE (p2) != TREE_VALUE (p1)) 48618334Speter { 48718334Speter tree memb; 488169689Skan tree mv1 = TREE_VALUE (p1); 489169689Skan if (mv1 && mv1 != error_mark_node 490169689Skan && TREE_CODE (mv1) != ARRAY_TYPE) 491169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 49218334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p2)); 49318334Speter memb; memb = TREE_CHAIN (memb)) 494169689Skan { 495169689Skan tree mv3 = TREE_TYPE (memb); 496169689Skan if (mv3 && mv3 != error_mark_node 497169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 498169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 499169689Skan if (comptypes (mv3, mv1)) 500169689Skan { 501169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 502169689Skan TREE_VALUE (p1)); 503169689Skan if (pedantic) 504169689Skan pedwarn ("function types not truly compatible in ISO C"); 505169689Skan goto parm_done; 506169689Skan } 507169689Skan } 50818334Speter } 509169689Skan TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2)); 51018334Speter parm_done: ; 51118334Speter } 51218334Speter 513169689Skan c_override_global_bindings_to_false = false; 51418334Speter t1 = build_function_type (valtype, newargs); 515169689Skan t1 = qualify_type (t1, t2); 51650397Sobrien /* ... falls through ... */ 51718334Speter } 51818334Speter 51918334Speter default: 52018334Speter return build_type_attribute_variant (t1, attributes); 52118334Speter } 52218334Speter 52318334Speter} 524169689Skan 525169689Skan/* Return the type of a conditional expression between pointers to 526169689Skan possibly differently qualified versions of compatible types. 527169689Skan 528169689Skan We assume that comp_target_types has already been done and returned 529169689Skan nonzero; if that isn't so, this may crash. */ 530169689Skan 531169689Skanstatic tree 532169689Skancommon_pointer_type (tree t1, tree t2) 533169689Skan{ 534169689Skan tree attributes; 535169689Skan tree pointed_to_1, mv1; 536169689Skan tree pointed_to_2, mv2; 537169689Skan tree target; 538169689Skan 539169689Skan /* Save time if the two types are the same. */ 540169689Skan 541169689Skan if (t1 == t2) return t1; 542169689Skan 543169689Skan /* If one type is nonsense, use the other. */ 544169689Skan if (t1 == error_mark_node) 545169689Skan return t2; 546169689Skan if (t2 == error_mark_node) 547169689Skan return t1; 548169689Skan 549260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 550260311Spfg gcc_assert ((TREE_CODE (t1) == POINTER_TYPE 551260311Spfg && TREE_CODE (t2) == POINTER_TYPE) 552260311Spfg || (TREE_CODE (t1) == BLOCK_POINTER_TYPE 553260311Spfg && TREE_CODE (t2) == BLOCK_POINTER_TYPE)); 554260311Spfg /* APPLE LOCAL end blocks 6065211 */ 555169689Skan 556169689Skan /* Merge the attributes. */ 557169689Skan attributes = targetm.merge_type_attributes (t1, t2); 558169689Skan 559169689Skan /* Find the composite type of the target types, and combine the 560169689Skan qualifiers of the two types' targets. Do not lose qualifiers on 561169689Skan array element types by taking the TYPE_MAIN_VARIANT. */ 562169689Skan mv1 = pointed_to_1 = TREE_TYPE (t1); 563169689Skan mv2 = pointed_to_2 = TREE_TYPE (t2); 564169689Skan if (TREE_CODE (mv1) != ARRAY_TYPE) 565169689Skan mv1 = TYPE_MAIN_VARIANT (pointed_to_1); 566169689Skan if (TREE_CODE (mv2) != ARRAY_TYPE) 567169689Skan mv2 = TYPE_MAIN_VARIANT (pointed_to_2); 568169689Skan target = composite_type (mv1, mv2); 569260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 570260311Spfg t1 = c_build_qualified_type (target, 571260311Spfg TYPE_QUALS (pointed_to_1) | 572260311Spfg TYPE_QUALS (pointed_to_2)); 573260311Spfg if (TREE_CODE (t2) == BLOCK_POINTER_TYPE) 574260311Spfg t1 = build_block_pointer_type (t1); 575260311Spfg else 576260311Spfg t1 = build_pointer_type (t1); 577260311Spfg /* APPLE LOCAL end blocks 6065211 */ 578169689Skan return build_type_attribute_variant (t1, attributes); 579169689Skan} 580169689Skan 581169689Skan/* Return the common type for two arithmetic types under the usual 582169689Skan arithmetic conversions. The default conversions have already been 583169689Skan applied, and enumerated types converted to their compatible integer 584169689Skan types. The resulting type is unqualified and has no attributes. 585169689Skan 586169689Skan This is the type for the result of most arithmetic operations 587169689Skan if the operands have the given two types. */ 588169689Skan 589169689Skanstatic tree 590169689Skanc_common_type (tree t1, tree t2) 591169689Skan{ 592169689Skan enum tree_code code1; 593169689Skan enum tree_code code2; 594169689Skan 595169689Skan /* If one type is nonsense, use the other. */ 596169689Skan if (t1 == error_mark_node) 597169689Skan return t2; 598169689Skan if (t2 == error_mark_node) 599169689Skan return t1; 600169689Skan 601169689Skan if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED) 602169689Skan t1 = TYPE_MAIN_VARIANT (t1); 603169689Skan 604169689Skan if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED) 605169689Skan t2 = TYPE_MAIN_VARIANT (t2); 606169689Skan 607169689Skan if (TYPE_ATTRIBUTES (t1) != NULL_TREE) 608169689Skan t1 = build_type_attribute_variant (t1, NULL_TREE); 609169689Skan 610169689Skan if (TYPE_ATTRIBUTES (t2) != NULL_TREE) 611169689Skan t2 = build_type_attribute_variant (t2, NULL_TREE); 612169689Skan 613169689Skan /* Save time if the two types are the same. */ 614169689Skan 615169689Skan if (t1 == t2) return t1; 616169689Skan 617169689Skan code1 = TREE_CODE (t1); 618169689Skan code2 = TREE_CODE (t2); 619169689Skan 620169689Skan gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE 621169689Skan || code1 == REAL_TYPE || code1 == INTEGER_TYPE); 622169689Skan gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE 623169689Skan || code2 == REAL_TYPE || code2 == INTEGER_TYPE); 624169689Skan 625169689Skan /* When one operand is a decimal float type, the other operand cannot be 626169689Skan a generic float type or a complex type. We also disallow vector types 627169689Skan here. */ 628169689Skan if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2)) 629169689Skan && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2))) 630169689Skan { 631169689Skan if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE) 632169689Skan { 633169689Skan error ("can%'t mix operands of decimal float and vector types"); 634169689Skan return error_mark_node; 635169689Skan } 636169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 637169689Skan { 638169689Skan error ("can%'t mix operands of decimal float and complex types"); 639169689Skan return error_mark_node; 640169689Skan } 641169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 642169689Skan { 643169689Skan error ("can%'t mix operands of decimal float and other float types"); 644169689Skan return error_mark_node; 645169689Skan } 646169689Skan } 647169689Skan 648169689Skan /* If one type is a vector type, return that type. (How the usual 649169689Skan arithmetic conversions apply to the vector types extension is not 650169689Skan precisely specified.) */ 651169689Skan if (code1 == VECTOR_TYPE) 652169689Skan return t1; 653169689Skan 654169689Skan if (code2 == VECTOR_TYPE) 655169689Skan return t2; 656169689Skan 657169689Skan /* If one type is complex, form the common type of the non-complex 658169689Skan components, then make that complex. Use T1 or T2 if it is the 659169689Skan required type. */ 660169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 661169689Skan { 662169689Skan tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 663169689Skan tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 664169689Skan tree subtype = c_common_type (subtype1, subtype2); 665169689Skan 666169689Skan if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 667169689Skan return t1; 668169689Skan else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 669169689Skan return t2; 670169689Skan else 671169689Skan return build_complex_type (subtype); 672169689Skan } 673169689Skan 674169689Skan /* If only one is real, use it as the result. */ 675169689Skan 676169689Skan if (code1 == REAL_TYPE && code2 != REAL_TYPE) 677169689Skan return t1; 678169689Skan 679169689Skan if (code2 == REAL_TYPE && code1 != REAL_TYPE) 680169689Skan return t2; 681169689Skan 682169689Skan /* If both are real and either are decimal floating point types, use 683169689Skan the decimal floating point type with the greater precision. */ 684169689Skan 685169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 686169689Skan { 687169689Skan if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node 688169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node) 689169689Skan return dfloat128_type_node; 690169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node 691169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node) 692169689Skan return dfloat64_type_node; 693169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node 694169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node) 695169689Skan return dfloat32_type_node; 696169689Skan } 697169689Skan 698169689Skan /* Both real or both integers; use the one with greater precision. */ 699169689Skan 700169689Skan if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 701169689Skan return t1; 702169689Skan else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 703169689Skan return t2; 704169689Skan 705169689Skan /* Same precision. Prefer long longs to longs to ints when the 706169689Skan same precision, following the C99 rules on integer type rank 707169689Skan (which are equivalent to the C90 rules for C90 types). */ 708169689Skan 709169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node 710169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node) 711169689Skan return long_long_unsigned_type_node; 712169689Skan 713169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node 714169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node) 715169689Skan { 716169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 717169689Skan return long_long_unsigned_type_node; 718169689Skan else 719169689Skan return long_long_integer_type_node; 720169689Skan } 721169689Skan 722169689Skan if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node 723169689Skan || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) 724169689Skan return long_unsigned_type_node; 725169689Skan 726169689Skan if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node 727169689Skan || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) 728169689Skan { 729169689Skan /* But preserve unsignedness from the other type, 730169689Skan since long cannot hold all the values of an unsigned int. */ 731169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 732169689Skan return long_unsigned_type_node; 733169689Skan else 734169689Skan return long_integer_type_node; 735169689Skan } 736169689Skan 737169689Skan /* Likewise, prefer long double to double even if same size. */ 738169689Skan if (TYPE_MAIN_VARIANT (t1) == long_double_type_node 739169689Skan || TYPE_MAIN_VARIANT (t2) == long_double_type_node) 740169689Skan return long_double_type_node; 741169689Skan 742169689Skan /* Otherwise prefer the unsigned one. */ 743169689Skan 744169689Skan if (TYPE_UNSIGNED (t1)) 745169689Skan return t1; 746169689Skan else 747169689Skan return t2; 748169689Skan} 74918334Speter 750169689Skan/* Wrapper around c_common_type that is used by c-common.c and other 751169689Skan front end optimizations that remove promotions. ENUMERAL_TYPEs 752169689Skan are allowed here and are converted to their compatible integer types. 753169689Skan BOOLEAN_TYPEs are allowed here and return either boolean_type_node or 754169689Skan preferably a non-Boolean type as the common type. */ 755169689Skantree 756169689Skancommon_type (tree t1, tree t2) 757169689Skan{ 758169689Skan if (TREE_CODE (t1) == ENUMERAL_TYPE) 759169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); 760169689Skan if (TREE_CODE (t2) == ENUMERAL_TYPE) 761169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); 762169689Skan 763169689Skan /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */ 764169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE 765169689Skan && TREE_CODE (t2) == BOOLEAN_TYPE) 766169689Skan return boolean_type_node; 767169689Skan 768169689Skan /* If either type is BOOLEAN_TYPE, then return the other. */ 769169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE) 770169689Skan return t2; 771169689Skan if (TREE_CODE (t2) == BOOLEAN_TYPE) 772169689Skan return t1; 773169689Skan 774169689Skan return c_common_type (t1, t2); 775169689Skan} 776169689Skan 77718334Speter/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 77818334Speter or various other operations. Return 2 if they are compatible 77918334Speter but a warning may be needed if you use them together. */ 78018334Speter 78118334Speterint 782169689Skancomptypes (tree type1, tree type2) 78318334Speter{ 784169689Skan const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base; 785169689Skan int val; 786169689Skan 787169689Skan val = comptypes_internal (type1, type2); 788169689Skan free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1); 789169689Skan 790169689Skan return val; 791169689Skan} 792169689Skan 793169689Skan/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 794169689Skan or various other operations. Return 2 if they are compatible 795169689Skan but a warning may be needed if you use them together. This 796169689Skan differs from comptypes, in that we don't free the seen types. */ 797169689Skan 798169689Skanstatic int 799169689Skancomptypes_internal (tree type1, tree type2) 800169689Skan{ 80190075Sobrien tree t1 = type1; 80290075Sobrien tree t2 = type2; 80318334Speter int attrval, val; 80418334Speter 80518334Speter /* Suppress errors caused by previously reported errors. */ 80618334Speter 80750397Sobrien if (t1 == t2 || !t1 || !t2 80850397Sobrien || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK) 80918334Speter return 1; 81018334Speter 81190075Sobrien /* If either type is the internal version of sizetype, return the 81290075Sobrien language version. */ 81390075Sobrien if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 814169689Skan && TYPE_ORIG_SIZE_TYPE (t1)) 815169689Skan t1 = TYPE_ORIG_SIZE_TYPE (t1); 81690075Sobrien 81790075Sobrien if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 818169689Skan && TYPE_ORIG_SIZE_TYPE (t2)) 819169689Skan t2 = TYPE_ORIG_SIZE_TYPE (t2); 82090075Sobrien 821169689Skan 822132718Skan /* Enumerated types are compatible with integer types, but this is 823132718Skan not transitive: two enumerated types in the same translation unit 824132718Skan are compatible with each other only if they are the same type. */ 82518334Speter 826132718Skan if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE) 827169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1)); 828132718Skan else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE) 829169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2)); 83018334Speter 83118334Speter if (t1 == t2) 83218334Speter return 1; 83318334Speter 83418334Speter /* Different classes of types can't be compatible. */ 83518334Speter 836132718Skan if (TREE_CODE (t1) != TREE_CODE (t2)) 837132718Skan return 0; 83818334Speter 839169689Skan /* Qualifiers must match. C99 6.7.3p9 */ 84018334Speter 84152284Sobrien if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 84218334Speter return 0; 84318334Speter 84418334Speter /* Allow for two different type nodes which have essentially the same 84518334Speter definition. Note that we already checked for equality of the type 84650397Sobrien qualifiers (just above). */ 84718334Speter 848169689Skan if (TREE_CODE (t1) != ARRAY_TYPE 849169689Skan && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 85018334Speter return 1; 85118334Speter 85218334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 853169689Skan if (!(attrval = targetm.comp_type_attributes (t1, t2))) 85418334Speter return 0; 85518334Speter 85618334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 85718334Speter val = 0; 85818334Speter 85918334Speter switch (TREE_CODE (t1)) 86018334Speter { 861260311Spfg /* APPLE LOCAL begin radar 5795493 */ 862260311Spfg case BLOCK_POINTER_TYPE: 863260311Spfg val = (TREE_CODE (t2) == BLOCK_POINTER_TYPE) && 864260311Spfg types_are_block_compatible (TREE_TYPE (t1), TREE_TYPE (t2)); 865260311Spfg break; 866260311Spfg 867260311Spfg /* APPLE LOCAL end radar 5795493 */ 86818334Speter case POINTER_TYPE: 869169689Skan /* Do not remove mode or aliasing information. */ 870169689Skan if (TYPE_MODE (t1) != TYPE_MODE (t2) 871169689Skan || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)) 872132718Skan break; 87318334Speter val = (TREE_TYPE (t1) == TREE_TYPE (t2) 874169689Skan ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))); 87518334Speter break; 87618334Speter 87718334Speter case FUNCTION_TYPE: 878169689Skan val = function_types_compatible_p (t1, t2); 87918334Speter break; 88018334Speter 88118334Speter case ARRAY_TYPE: 88218334Speter { 88318334Speter tree d1 = TYPE_DOMAIN (t1); 88418334Speter tree d2 = TYPE_DOMAIN (t2); 88590075Sobrien bool d1_variable, d2_variable; 88690075Sobrien bool d1_zero, d2_zero; 88718334Speter val = 1; 88818334Speter 88918334Speter /* Target types must match incl. qualifiers. */ 89018334Speter if (TREE_TYPE (t1) != TREE_TYPE (t2) 891169689Skan && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)))) 89218334Speter return 0; 89318334Speter 89418334Speter /* Sizes must match unless one is missing or variable. */ 89590075Sobrien if (d1 == 0 || d2 == 0 || d1 == d2) 89618334Speter break; 89718334Speter 898169689Skan d1_zero = !TYPE_MAX_VALUE (d1); 899169689Skan d2_zero = !TYPE_MAX_VALUE (d2); 90090075Sobrien 901169689Skan d1_variable = (!d1_zero 90290075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 90390075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 904169689Skan d2_variable = (!d2_zero 90590075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 90690075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 907169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 908169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 90990075Sobrien 91090075Sobrien if (d1_variable || d2_variable) 91190075Sobrien break; 91290075Sobrien if (d1_zero && d2_zero) 91390075Sobrien break; 91490075Sobrien if (d1_zero || d2_zero 915169689Skan || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)) 916169689Skan || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2))) 91790075Sobrien val = 0; 91890075Sobrien 919169689Skan break; 92018334Speter } 92118334Speter 922169689Skan case ENUMERAL_TYPE: 92318334Speter case RECORD_TYPE: 924132718Skan case UNION_TYPE: 925132718Skan if (val != 1 && !same_translation_unit_p (t1, t2)) 926169689Skan { 927169689Skan tree a1 = TYPE_ATTRIBUTES (t1); 928169689Skan tree a2 = TYPE_ATTRIBUTES (t2); 929169689Skan 930169689Skan if (! attribute_list_contained (a1, a2) 931169689Skan && ! attribute_list_contained (a2, a1)) 932169689Skan break; 933169689Skan 934169689Skan if (attrval != 2) 935169689Skan return tagged_types_tu_compatible_p (t1, t2); 936169689Skan val = tagged_types_tu_compatible_p (t1, t2); 937169689Skan } 93818334Speter break; 93950397Sobrien 940132718Skan case VECTOR_TYPE: 941169689Skan val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 942169689Skan && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)); 943132718Skan break; 944132718Skan 94550397Sobrien default: 94650397Sobrien break; 94718334Speter } 94818334Speter return attrval == 2 && val == 1 ? 2 : val; 94918334Speter} 95018334Speter 95118334Speter/* Return 1 if TTL and TTR are pointers to types that are equivalent, 952169689Skan ignoring their qualifiers. */ 95318334Speter 95418334Speterstatic int 955169689Skancomp_target_types (tree ttl, tree ttr) 95618334Speter{ 95718334Speter int val; 958169689Skan tree mvl, mvr; 95918334Speter 960260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 961260311Spfg if (TREE_CODE (ttl) == BLOCK_POINTER_TYPE 962260311Spfg && TREE_CODE (ttr) == BLOCK_POINTER_TYPE) 963260311Spfg return types_are_block_compatible (TREE_TYPE (ttl), 964260311Spfg TREE_TYPE (ttr)); 965260311Spfg if (TREE_CODE (ttl) != TREE_CODE (ttr)) 966260311Spfg return 0; 967260311Spfg /* APPLE LOCAL end blocks 6065211 */ 968260311Spfg 969169689Skan /* Do not lose qualifiers on element types of array types that are 970169689Skan pointer targets by taking their TYPE_MAIN_VARIANT. */ 971169689Skan mvl = TREE_TYPE (ttl); 972169689Skan mvr = TREE_TYPE (ttr); 973169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 974169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 975169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 976169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 977169689Skan val = comptypes (mvl, mvr); 97818334Speter 97918334Speter if (val == 2 && pedantic) 98018334Speter pedwarn ("types are not quite compatible"); 98118334Speter return val; 98218334Speter} 98318334Speter 98418334Speter/* Subroutines of `comptypes'. */ 98518334Speter 986169689Skan/* Determine whether two trees derive from the same translation unit. 987169689Skan If the CONTEXT chain ends in a null, that tree's context is still 988169689Skan being parsed, so if two trees have context chains ending in null, 989132718Skan they're in the same translation unit. */ 990169689Skanint 991132718Skansame_translation_unit_p (tree t1, tree t2) 992132718Skan{ 993132718Skan while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL) 994132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t1))) 995132718Skan { 996169689Skan case tcc_declaration: 997169689Skan t1 = DECL_CONTEXT (t1); break; 998169689Skan case tcc_type: 999169689Skan t1 = TYPE_CONTEXT (t1); break; 1000169689Skan case tcc_exceptional: 1001169689Skan t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */ 1002169689Skan default: gcc_unreachable (); 1003132718Skan } 1004132718Skan 1005132718Skan while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL) 1006132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t2))) 1007132718Skan { 1008169689Skan case tcc_declaration: 1009169689Skan t2 = DECL_CONTEXT (t2); break; 1010169689Skan case tcc_type: 1011169689Skan t2 = TYPE_CONTEXT (t2); break; 1012169689Skan case tcc_exceptional: 1013169689Skan t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */ 1014169689Skan default: gcc_unreachable (); 1015132718Skan } 1016132718Skan 1017132718Skan return t1 == t2; 1018132718Skan} 1019132718Skan 1020169689Skan/* Allocate the seen two types, assuming that they are compatible. */ 1021132718Skan 1022169689Skanstatic struct tagged_tu_seen_cache * 1023169689Skanalloc_tagged_tu_seen_cache (tree t1, tree t2) 1024169689Skan{ 1025169689Skan struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache); 1026169689Skan tu->next = tagged_tu_seen_base; 1027169689Skan tu->t1 = t1; 1028169689Skan tu->t2 = t2; 1029132718Skan 1030169689Skan tagged_tu_seen_base = tu; 1031132718Skan 1032169689Skan /* The C standard says that two structures in different translation 1033169689Skan units are compatible with each other only if the types of their 1034169689Skan fields are compatible (among other things). We assume that they 1035169689Skan are compatible until proven otherwise when building the cache. 1036169689Skan An example where this can occur is: 1037169689Skan struct a 1038169689Skan { 1039169689Skan struct a *next; 1040169689Skan }; 1041169689Skan If we are comparing this against a similar struct in another TU, 1042169689Skan and did not assume they were compatible, we end up with an infinite 1043169689Skan loop. */ 1044169689Skan tu->val = 1; 1045169689Skan return tu; 1046169689Skan} 1047132718Skan 1048169689Skan/* Free the seen types until we get to TU_TIL. */ 1049169689Skan 1050169689Skanstatic void 1051169689Skanfree_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til) 1052169689Skan{ 1053169689Skan const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base; 1054169689Skan while (tu != tu_til) 1055169689Skan { 1056169689Skan struct tagged_tu_seen_cache *tu1 = (struct tagged_tu_seen_cache*)tu; 1057169689Skan tu = tu1->next; 1058169689Skan free (tu1); 1059169689Skan } 1060169689Skan tagged_tu_seen_base = tu_til; 1061169689Skan} 1062169689Skan 1063132718Skan/* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are 1064132718Skan compatible. If the two types are not the same (which has been 1065132718Skan checked earlier), this can only happen when multiple translation 1066132718Skan units are being compiled. See C99 6.2.7 paragraph 1 for the exact 1067132718Skan rules. */ 1068132718Skan 1069132718Skanstatic int 1070169689Skantagged_types_tu_compatible_p (tree t1, tree t2) 1071132718Skan{ 1072132718Skan tree s1, s2; 1073132718Skan bool needs_warning = false; 1074132718Skan 1075132718Skan /* We have to verify that the tags of the types are the same. This 1076132718Skan is harder than it looks because this may be a typedef, so we have 1077132718Skan to go look at the original type. It may even be a typedef of a 1078169689Skan typedef... 1079169689Skan In the case of compiler-created builtin structs the TYPE_DECL 1080169689Skan may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */ 1081132718Skan while (TYPE_NAME (t1) 1082132718Skan && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL 1083132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t1))) 1084132718Skan t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1)); 1085132718Skan 1086132718Skan while (TYPE_NAME (t2) 1087132718Skan && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL 1088132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t2))) 1089132718Skan t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2)); 1090132718Skan 1091132718Skan /* C90 didn't have the requirement that the two tags be the same. */ 1092132718Skan if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2)) 1093132718Skan return 0; 1094132718Skan 1095132718Skan /* C90 didn't say what happened if one or both of the types were 1096132718Skan incomplete; we choose to follow C99 rules here, which is that they 1097132718Skan are compatible. */ 1098132718Skan if (TYPE_SIZE (t1) == NULL 1099132718Skan || TYPE_SIZE (t2) == NULL) 1100132718Skan return 1; 1101132718Skan 1102132718Skan { 1103169689Skan const struct tagged_tu_seen_cache * tts_i; 1104132718Skan for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next) 1105132718Skan if (tts_i->t1 == t1 && tts_i->t2 == t2) 1106169689Skan return tts_i->val; 1107132718Skan } 1108132718Skan 1109132718Skan switch (TREE_CODE (t1)) 1110132718Skan { 1111132718Skan case ENUMERAL_TYPE: 1112132718Skan { 1113169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1114169689Skan /* Speed up the case where the type values are in the same order. */ 1115169689Skan tree tv1 = TYPE_VALUES (t1); 1116169689Skan tree tv2 = TYPE_VALUES (t2); 1117169689Skan 1118169689Skan if (tv1 == tv2) 1119169689Skan { 1120169689Skan return 1; 1121169689Skan } 1122169689Skan 1123169689Skan for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2)) 1124169689Skan { 1125169689Skan if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2)) 1126169689Skan break; 1127169689Skan if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1) 1128169689Skan { 1129169689Skan tu->val = 0; 1130169689Skan return 0; 1131169689Skan } 1132169689Skan } 1133169689Skan 1134169689Skan if (tv1 == NULL_TREE && tv2 == NULL_TREE) 1135169689Skan { 1136169689Skan return 1; 1137169689Skan } 1138169689Skan if (tv1 == NULL_TREE || tv2 == NULL_TREE) 1139169689Skan { 1140169689Skan tu->val = 0; 1141169689Skan return 0; 1142169689Skan } 1143169689Skan 1144132718Skan if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2))) 1145169689Skan { 1146169689Skan tu->val = 0; 1147169689Skan return 0; 1148169689Skan } 1149132718Skan 1150132718Skan for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1)) 1151132718Skan { 1152132718Skan s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2)); 1153132718Skan if (s2 == NULL 1154132718Skan || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1) 1155169689Skan { 1156169689Skan tu->val = 0; 1157169689Skan return 0; 1158169689Skan } 1159132718Skan } 1160132718Skan return 1; 1161132718Skan } 1162132718Skan 1163132718Skan case UNION_TYPE: 1164132718Skan { 1165169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1166132718Skan if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2))) 1167169689Skan { 1168169689Skan tu->val = 0; 1169169689Skan return 0; 1170169689Skan } 1171132718Skan 1172169689Skan /* Speed up the common case where the fields are in the same order. */ 1173169689Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2; 1174169689Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1175169689Skan { 1176169689Skan int result; 1177169689Skan 1178169689Skan 1179169689Skan if (DECL_NAME (s1) == NULL 1180169689Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1181169689Skan break; 1182169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1183169689Skan if (result == 0) 1184169689Skan { 1185169689Skan tu->val = 0; 1186169689Skan return 0; 1187169689Skan } 1188169689Skan if (result == 2) 1189169689Skan needs_warning = true; 1190169689Skan 1191169689Skan if (TREE_CODE (s1) == FIELD_DECL 1192169689Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1193169689Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1194169689Skan { 1195169689Skan tu->val = 0; 1196169689Skan return 0; 1197169689Skan } 1198169689Skan } 1199169689Skan if (!s1 && !s2) 1200169689Skan { 1201169689Skan tu->val = needs_warning ? 2 : 1; 1202169689Skan return tu->val; 1203169689Skan } 1204169689Skan 1205132718Skan for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1)) 1206132718Skan { 1207132718Skan bool ok = false; 1208132718Skan 1209132718Skan if (DECL_NAME (s1) != NULL) 1210169689Skan for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2)) 1211132718Skan if (DECL_NAME (s1) == DECL_NAME (s2)) 1212132718Skan { 1213132718Skan int result; 1214169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1215132718Skan if (result == 0) 1216169689Skan { 1217169689Skan tu->val = 0; 1218169689Skan return 0; 1219169689Skan } 1220132718Skan if (result == 2) 1221132718Skan needs_warning = true; 1222132718Skan 1223132718Skan if (TREE_CODE (s1) == FIELD_DECL 1224132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1225132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1226132718Skan break; 1227132718Skan 1228132718Skan ok = true; 1229132718Skan break; 1230132718Skan } 1231169689Skan if (!ok) 1232169689Skan { 1233169689Skan tu->val = 0; 1234169689Skan return 0; 1235169689Skan } 1236132718Skan } 1237169689Skan tu->val = needs_warning ? 2 : 10; 1238169689Skan return tu->val; 1239132718Skan } 1240132718Skan 1241132718Skan case RECORD_TYPE: 1242132718Skan { 1243169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1244132718Skan 1245132718Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); 1246132718Skan s1 && s2; 1247132718Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1248132718Skan { 1249132718Skan int result; 1250132718Skan if (TREE_CODE (s1) != TREE_CODE (s2) 1251132718Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1252132718Skan break; 1253169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1254132718Skan if (result == 0) 1255132718Skan break; 1256132718Skan if (result == 2) 1257132718Skan needs_warning = true; 1258132718Skan 1259132718Skan if (TREE_CODE (s1) == FIELD_DECL 1260132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1261132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1262132718Skan break; 1263132718Skan } 1264132718Skan if (s1 && s2) 1265169689Skan tu->val = 0; 1266169689Skan else 1267169689Skan tu->val = needs_warning ? 2 : 1; 1268169689Skan return tu->val; 1269132718Skan } 1270132718Skan 1271132718Skan default: 1272169689Skan gcc_unreachable (); 1273132718Skan } 1274132718Skan} 1275132718Skan 127618334Speter/* Return 1 if two function types F1 and F2 are compatible. 127718334Speter If either type specifies no argument types, 127818334Speter the other must specify a fixed number of self-promoting arg types. 1279132718Skan Otherwise, if one type specifies only the number of arguments, 128018334Speter the other must specify that number of self-promoting arg types. 128118334Speter Otherwise, the argument types must match. */ 128218334Speter 128318334Speterstatic int 1284169689Skanfunction_types_compatible_p (tree f1, tree f2) 128518334Speter{ 128618334Speter tree args1, args2; 128718334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 128818334Speter int val = 1; 128918334Speter int val1; 1290132718Skan tree ret1, ret2; 129118334Speter 1292132718Skan ret1 = TREE_TYPE (f1); 1293132718Skan ret2 = TREE_TYPE (f2); 1294132718Skan 1295169689Skan /* 'volatile' qualifiers on a function's return type used to mean 1296169689Skan the function is noreturn. */ 1297169689Skan if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2)) 1298169689Skan pedwarn ("function return types not compatible due to %<volatile%>"); 1299132718Skan if (TYPE_VOLATILE (ret1)) 1300132718Skan ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1), 1301132718Skan TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE); 1302132718Skan if (TYPE_VOLATILE (ret2)) 1303132718Skan ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2), 1304132718Skan TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE); 1305169689Skan val = comptypes_internal (ret1, ret2); 1306132718Skan if (val == 0) 130718334Speter return 0; 130818334Speter 130918334Speter args1 = TYPE_ARG_TYPES (f1); 131018334Speter args2 = TYPE_ARG_TYPES (f2); 131118334Speter 131218334Speter /* An unspecified parmlist matches any specified parmlist 131318334Speter whose argument types don't need default promotions. */ 131418334Speter 131518334Speter if (args1 == 0) 131618334Speter { 131718334Speter if (!self_promoting_args_p (args2)) 131818334Speter return 0; 131918334Speter /* If one of these types comes from a non-prototype fn definition, 132018334Speter compare that with the other type's arglist. 132118334Speter If they don't match, ask for a warning (but no error). */ 132218334Speter if (TYPE_ACTUAL_ARG_TYPES (f1) 1323169689Skan && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1))) 132418334Speter val = 2; 132518334Speter return val; 132618334Speter } 132718334Speter if (args2 == 0) 132818334Speter { 132918334Speter if (!self_promoting_args_p (args1)) 133018334Speter return 0; 133118334Speter if (TYPE_ACTUAL_ARG_TYPES (f2) 1332169689Skan && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2))) 133318334Speter val = 2; 133418334Speter return val; 133518334Speter } 133618334Speter 133718334Speter /* Both types have argument lists: compare them and propagate results. */ 1338169689Skan val1 = type_lists_compatible_p (args1, args2); 133918334Speter return val1 != 1 ? val1 : val; 134018334Speter} 134118334Speter 134218334Speter/* Check two lists of types for compatibility, 134318334Speter returning 0 for incompatible, 1 for compatible, 134418334Speter or 2 for compatible with warning. */ 134518334Speter 134618334Speterstatic int 1347169689Skantype_lists_compatible_p (tree args1, tree args2) 134818334Speter{ 134918334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 135018334Speter int val = 1; 135118334Speter int newval = 0; 135218334Speter 135318334Speter while (1) 135418334Speter { 1355169689Skan tree a1, mv1, a2, mv2; 135618334Speter if (args1 == 0 && args2 == 0) 135718334Speter return val; 135818334Speter /* If one list is shorter than the other, 135918334Speter they fail to match. */ 136018334Speter if (args1 == 0 || args2 == 0) 136118334Speter return 0; 1362169689Skan mv1 = a1 = TREE_VALUE (args1); 1363169689Skan mv2 = a2 = TREE_VALUE (args2); 1364169689Skan if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE) 1365169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 1366169689Skan if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE) 1367169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 136818334Speter /* A null pointer instead of a type 136918334Speter means there is supposed to be an argument 137018334Speter but nothing is specified about what type it has. 137118334Speter So match anything that self-promotes. */ 1372169689Skan if (a1 == 0) 137318334Speter { 1374169689Skan if (c_type_promotes_to (a2) != a2) 137518334Speter return 0; 137618334Speter } 1377169689Skan else if (a2 == 0) 137818334Speter { 1379169689Skan if (c_type_promotes_to (a1) != a1) 138018334Speter return 0; 138118334Speter } 1382132718Skan /* If one of the lists has an error marker, ignore this arg. */ 1383169689Skan else if (TREE_CODE (a1) == ERROR_MARK 1384169689Skan || TREE_CODE (a2) == ERROR_MARK) 1385132718Skan ; 1386169689Skan else if (!(newval = comptypes_internal (mv1, mv2))) 138718334Speter { 138818334Speter /* Allow wait (union {union wait *u; int *i} *) 138918334Speter and wait (union wait *) to be compatible. */ 1390169689Skan if (TREE_CODE (a1) == UNION_TYPE 1391169689Skan && (TYPE_NAME (a1) == 0 1392169689Skan || TYPE_TRANSPARENT_UNION (a1)) 1393169689Skan && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST 1394169689Skan && tree_int_cst_equal (TYPE_SIZE (a1), 1395169689Skan TYPE_SIZE (a2))) 139618334Speter { 139718334Speter tree memb; 1398169689Skan for (memb = TYPE_FIELDS (a1); 139918334Speter memb; memb = TREE_CHAIN (memb)) 1400169689Skan { 1401169689Skan tree mv3 = TREE_TYPE (memb); 1402169689Skan if (mv3 && mv3 != error_mark_node 1403169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1404169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1405169689Skan if (comptypes_internal (mv3, mv2)) 1406169689Skan break; 1407169689Skan } 140818334Speter if (memb == 0) 140918334Speter return 0; 141018334Speter } 1411169689Skan else if (TREE_CODE (a2) == UNION_TYPE 1412169689Skan && (TYPE_NAME (a2) == 0 1413169689Skan || TYPE_TRANSPARENT_UNION (a2)) 1414169689Skan && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST 1415169689Skan && tree_int_cst_equal (TYPE_SIZE (a2), 1416169689Skan TYPE_SIZE (a1))) 141718334Speter { 141818334Speter tree memb; 1419169689Skan for (memb = TYPE_FIELDS (a2); 142018334Speter memb; memb = TREE_CHAIN (memb)) 1421169689Skan { 1422169689Skan tree mv3 = TREE_TYPE (memb); 1423169689Skan if (mv3 && mv3 != error_mark_node 1424169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1425169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1426169689Skan if (comptypes_internal (mv3, mv1)) 1427169689Skan break; 1428169689Skan } 142918334Speter if (memb == 0) 143018334Speter return 0; 143118334Speter } 143218334Speter else 143318334Speter return 0; 143418334Speter } 143518334Speter 143618334Speter /* comptypes said ok, but record if it said to warn. */ 143718334Speter if (newval > val) 143818334Speter val = newval; 143918334Speter 144018334Speter args1 = TREE_CHAIN (args1); 144118334Speter args2 = TREE_CHAIN (args2); 144218334Speter } 144318334Speter} 144418334Speter 144518334Speter/* Compute the size to increment a pointer by. */ 144618334Speter 1447169689Skanstatic tree 1448132718Skanc_size_in_bytes (tree type) 144918334Speter{ 145018334Speter enum tree_code code = TREE_CODE (type); 145118334Speter 145290075Sobrien if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 145390075Sobrien return size_one_node; 145490075Sobrien 145590075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (type)) 145618334Speter { 145718334Speter error ("arithmetic on pointer to an incomplete type"); 145890075Sobrien return size_one_node; 145918334Speter } 146018334Speter 146118334Speter /* Convert in case a char is more than one unit. */ 146290075Sobrien return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 146390075Sobrien size_int (TYPE_PRECISION (char_type_node) 146490075Sobrien / BITS_PER_UNIT)); 146518334Speter} 146618334Speter 146790075Sobrien/* Return either DECL or its known constant value (if it has one). */ 146818334Speter 146918334Spetertree 1470132718Skandecl_constant_value (tree decl) 147118334Speter{ 147250397Sobrien if (/* Don't change a variable array bound or initial value to a constant 1473169689Skan in a place where a variable is invalid. Note that DECL_INITIAL 1474169689Skan isn't valid for a PARM_DECL. */ 147550397Sobrien current_function_decl != 0 1476169689Skan && TREE_CODE (decl) != PARM_DECL 1477169689Skan && !TREE_THIS_VOLATILE (decl) 147890075Sobrien && TREE_READONLY (decl) 147918334Speter && DECL_INITIAL (decl) != 0 148018334Speter && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK 148118334Speter /* This is invalid if initial value is not constant. 148218334Speter If it has either a function call, a memory reference, 148318334Speter or a variable, then re-evaluating it could give different results. */ 148418334Speter && TREE_CONSTANT (DECL_INITIAL (decl)) 148518334Speter /* Check for cases where this is sub-optimal, even though valid. */ 148690075Sobrien && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR) 148718334Speter return DECL_INITIAL (decl); 148818334Speter return decl; 148918334Speter} 149018334Speter 149190075Sobrien/* Return either DECL or its known constant value (if it has one), but 149290075Sobrien return DECL if pedantic or DECL has mode BLKmode. This is for 149390075Sobrien bug-compatibility with the old behavior of decl_constant_value 149490075Sobrien (before GCC 3.0); every use of this function is a bug and it should 149590075Sobrien be removed before GCC 3.1. It is not appropriate to use pedantic 149690075Sobrien in a way that affects optimization, and BLKmode is probably not the 149790075Sobrien right test for avoiding misoptimizations either. */ 149818334Speter 149990075Sobrienstatic tree 1500132718Skandecl_constant_value_for_broken_optimization (tree decl) 150118334Speter{ 1502169689Skan tree ret; 1503169689Skan 150490075Sobrien if (pedantic || DECL_MODE (decl) == BLKmode) 150590075Sobrien return decl; 1506169689Skan 1507169689Skan ret = decl_constant_value (decl); 1508169689Skan /* Avoid unwanted tree sharing between the initializer and current 1509169689Skan function's body where the tree can be modified e.g. by the 1510169689Skan gimplifier. */ 1511169689Skan if (ret != decl && TREE_STATIC (decl)) 1512169689Skan ret = unshare_expr (ret); 1513169689Skan return ret; 151490075Sobrien} 151518334Speter 1516169689Skan/* Convert the array expression EXP to a pointer. */ 1517260311Spfg/* APPLE LOCAL radar 6212722 */ 1518260311Spfgtree 1519169689Skanarray_to_pointer_conversion (tree exp) 152090075Sobrien{ 1521169689Skan tree orig_exp = exp; 152290075Sobrien tree type = TREE_TYPE (exp); 1523169689Skan tree adr; 1524169689Skan tree restype = TREE_TYPE (type); 1525169689Skan tree ptrtype; 152690075Sobrien 1527169689Skan gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 152890075Sobrien 1529169689Skan STRIP_TYPE_NOPS (exp); 153018334Speter 1531169689Skan if (TREE_NO_WARNING (orig_exp)) 1532169689Skan TREE_NO_WARNING (exp) = 1; 153350397Sobrien 1534169689Skan ptrtype = build_pointer_type (restype); 1535169689Skan 1536169689Skan if (TREE_CODE (exp) == INDIRECT_REF) 1537169689Skan return convert (ptrtype, TREE_OPERAND (exp, 0)); 1538169689Skan 1539169689Skan if (TREE_CODE (exp) == VAR_DECL) 154018334Speter { 1541169689Skan /* We are making an ADDR_EXPR of ptrtype. This is a valid 1542169689Skan ADDR_EXPR because it's the best way of representing what 1543169689Skan happens in C when we take the address of an array and place 1544169689Skan it in a pointer to the element type. */ 1545169689Skan adr = build1 (ADDR_EXPR, ptrtype, exp); 1546169689Skan if (!c_mark_addressable (exp)) 1547169689Skan return error_mark_node; 1548169689Skan TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ 1549169689Skan return adr; 155018334Speter } 155118334Speter 1552169689Skan /* This way is better for a COMPONENT_REF since it can 1553169689Skan simplify the offset for a component. */ 1554169689Skan adr = build_unary_op (ADDR_EXPR, exp, 1); 1555169689Skan return convert (ptrtype, adr); 1556169689Skan} 155718334Speter 1558169689Skan/* Convert the function expression EXP to a pointer. */ 1559260311Spfg/* APPLE LOCAL radar 6212722 */ 1560260311Spfgtree 1561169689Skanfunction_to_pointer_conversion (tree exp) 1562169689Skan{ 1563169689Skan tree orig_exp = exp; 156418334Speter 1565169689Skan gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE); 156618334Speter 1567169689Skan STRIP_TYPE_NOPS (exp); 156818334Speter 1569169689Skan if (TREE_NO_WARNING (orig_exp)) 1570169689Skan TREE_NO_WARNING (exp) = 1; 157118334Speter 1572169689Skan return build_unary_op (ADDR_EXPR, exp, 0); 157318334Speter} 157490075Sobrien 1575169689Skan/* Perform the default conversion of arrays and functions to pointers. 1576169689Skan Return the result of converting EXP. For any other expression, just 1577169689Skan return EXP after removing NOPs. */ 157890075Sobrien 1579169689Skanstruct c_expr 1580169689Skandefault_function_array_conversion (struct c_expr exp) 158190075Sobrien{ 1582169689Skan tree orig_exp = exp.value; 1583169689Skan tree type = TREE_TYPE (exp.value); 158490075Sobrien enum tree_code code = TREE_CODE (type); 158590075Sobrien 1586169689Skan switch (code) 1587169689Skan { 1588169689Skan case ARRAY_TYPE: 1589169689Skan { 1590169689Skan bool not_lvalue = false; 1591169689Skan bool lvalue_array_p; 159290075Sobrien 1593169689Skan while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR 1594169689Skan || TREE_CODE (exp.value) == NOP_EXPR 1595169689Skan || TREE_CODE (exp.value) == CONVERT_EXPR) 1596169689Skan && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type) 1597169689Skan { 1598169689Skan if (TREE_CODE (exp.value) == NON_LVALUE_EXPR) 1599169689Skan not_lvalue = true; 1600169689Skan exp.value = TREE_OPERAND (exp.value, 0); 1601169689Skan } 160290075Sobrien 1603169689Skan if (TREE_NO_WARNING (orig_exp)) 1604169689Skan TREE_NO_WARNING (exp.value) = 1; 1605169689Skan 1606169689Skan lvalue_array_p = !not_lvalue && lvalue_p (exp.value); 1607169689Skan if (!flag_isoc99 && !lvalue_array_p) 1608169689Skan { 1609169689Skan /* Before C99, non-lvalue arrays do not decay to pointers. 1610169689Skan Normally, using such an array would be invalid; but it can 1611169689Skan be used correctly inside sizeof or as a statement expression. 1612169689Skan Thus, do not give an error here; an error will result later. */ 1613169689Skan return exp; 1614169689Skan } 1615169689Skan 1616169689Skan exp.value = array_to_pointer_conversion (exp.value); 1617169689Skan } 1618169689Skan break; 1619169689Skan case FUNCTION_TYPE: 1620169689Skan exp.value = function_to_pointer_conversion (exp.value); 1621169689Skan break; 1622169689Skan default: 1623169689Skan STRIP_TYPE_NOPS (exp.value); 1624169689Skan if (TREE_NO_WARNING (orig_exp)) 1625169689Skan TREE_NO_WARNING (exp.value) = 1; 1626169689Skan break; 162790075Sobrien } 162890075Sobrien 1629169689Skan return exp; 1630169689Skan} 163190075Sobrien 163290075Sobrien 1633169689Skan/* EXP is an expression of integer type. Apply the integer promotions 1634169689Skan to it and return the promoted value. */ 163590075Sobrien 1636169689Skantree 1637169689Skanperform_integral_promotions (tree exp) 1638169689Skan{ 1639169689Skan tree type = TREE_TYPE (exp); 1640169689Skan enum tree_code code = TREE_CODE (type); 1641169689Skan 1642169689Skan gcc_assert (INTEGRAL_TYPE_P (type)); 1643169689Skan 164490075Sobrien /* Normally convert enums to int, 164590075Sobrien but convert wide enums to something wider. */ 164690075Sobrien if (code == ENUMERAL_TYPE) 164790075Sobrien { 1648117395Skan type = c_common_type_for_size (MAX (TYPE_PRECISION (type), 1649117395Skan TYPE_PRECISION (integer_type_node)), 1650117395Skan ((TYPE_PRECISION (type) 1651117395Skan >= TYPE_PRECISION (integer_type_node)) 1652169689Skan && TYPE_UNSIGNED (type))); 165390075Sobrien 165490075Sobrien return convert (type, exp); 165590075Sobrien } 165690075Sobrien 1657169689Skan /* ??? This should no longer be needed now bit-fields have their 1658169689Skan proper types. */ 165990075Sobrien if (TREE_CODE (exp) == COMPONENT_REF 166090075Sobrien && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) 166190075Sobrien /* If it's thinner than an int, promote it like a 166290075Sobrien c_promoting_integer_type_p, otherwise leave it alone. */ 166390075Sobrien && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), 166490075Sobrien TYPE_PRECISION (integer_type_node))) 1665117395Skan return convert (integer_type_node, exp); 166690075Sobrien 166790075Sobrien if (c_promoting_integer_type_p (type)) 166890075Sobrien { 1669117395Skan /* Preserve unsignedness if not really getting any wider. */ 1670169689Skan if (TYPE_UNSIGNED (type) 1671117395Skan && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 167290075Sobrien return convert (unsigned_type_node, exp); 167390075Sobrien 167490075Sobrien return convert (integer_type_node, exp); 167590075Sobrien } 167690075Sobrien 1677169689Skan return exp; 1678169689Skan} 1679169689Skan 1680169689Skan 1681169689Skan/* Perform default promotions for C data used in expressions. 1682169689Skan Enumeral types or short or char are converted to int. 1683169689Skan In addition, manifest constants symbols are replaced by their values. */ 1684169689Skan 1685169689Skantree 1686169689Skandefault_conversion (tree exp) 1687169689Skan{ 1688169689Skan tree orig_exp; 1689169689Skan tree type = TREE_TYPE (exp); 1690169689Skan enum tree_code code = TREE_CODE (type); 1691169689Skan 1692169689Skan /* Functions and arrays have been converted during parsing. */ 1693169689Skan gcc_assert (code != FUNCTION_TYPE); 1694169689Skan if (code == ARRAY_TYPE) 1695169689Skan return exp; 1696169689Skan 1697169689Skan /* Constants can be used directly unless they're not loadable. */ 1698169689Skan if (TREE_CODE (exp) == CONST_DECL) 1699169689Skan exp = DECL_INITIAL (exp); 1700169689Skan 1701169689Skan /* Replace a nonvolatile const static variable with its value unless 1702169689Skan it is an array, in which case we must be sure that taking the 1703169689Skan address of the array produces consistent results. */ 1704169689Skan else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) 1705169689Skan { 1706169689Skan exp = decl_constant_value_for_broken_optimization (exp); 1707169689Skan type = TREE_TYPE (exp); 1708169689Skan } 1709169689Skan 1710169689Skan /* Strip no-op conversions. */ 1711169689Skan orig_exp = exp; 1712169689Skan STRIP_TYPE_NOPS (exp); 1713169689Skan 1714169689Skan if (TREE_NO_WARNING (orig_exp)) 1715169689Skan TREE_NO_WARNING (exp) = 1; 1716169689Skan 1717169689Skan if (INTEGRAL_TYPE_P (type)) 1718169689Skan return perform_integral_promotions (exp); 1719169689Skan 172090075Sobrien if (code == VOID_TYPE) 172190075Sobrien { 172290075Sobrien error ("void value not ignored as it ought to be"); 172390075Sobrien return error_mark_node; 172490075Sobrien } 172590075Sobrien return exp; 172690075Sobrien} 172718334Speter 172890075Sobrien/* Look up COMPONENT in a structure or union DECL. 172918334Speter 173090075Sobrien If the component name is not found, returns NULL_TREE. Otherwise, 173190075Sobrien the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL 173290075Sobrien stepping down the chain to the component, which is in the last 173390075Sobrien TREE_VALUE of the list. Normally the list is of length one, but if 173490075Sobrien the component is embedded within (nested) anonymous structures or 173590075Sobrien unions, the list steps down the chain to the component. */ 1736132718Skan 173718334Speterstatic tree 1738132718Skanlookup_field (tree decl, tree component) 173918334Speter{ 174090075Sobrien tree type = TREE_TYPE (decl); 174118334Speter tree field; 174218334Speter 174318334Speter /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers 174418334Speter to the field elements. Use a binary search on this array to quickly 174518334Speter find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC 174618334Speter will always be set for structures which have many elements. */ 174718334Speter 1748169689Skan if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s) 174918334Speter { 175018334Speter int bot, top, half; 1751132718Skan tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0]; 175218334Speter 175318334Speter field = TYPE_FIELDS (type); 175418334Speter bot = 0; 1755132718Skan top = TYPE_LANG_SPECIFIC (type)->s->len; 175618334Speter while (top - bot > 1) 175718334Speter { 175818334Speter half = (top - bot + 1) >> 1; 175918334Speter field = field_array[bot+half]; 176018334Speter 176118334Speter if (DECL_NAME (field) == NULL_TREE) 176218334Speter { 176318334Speter /* Step through all anon unions in linear fashion. */ 176418334Speter while (DECL_NAME (field_array[bot]) == NULL_TREE) 176518334Speter { 176618334Speter field = field_array[bot++]; 176750397Sobrien if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 176850397Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 176990075Sobrien { 177090075Sobrien tree anon = lookup_field (field, component); 177150397Sobrien 177290075Sobrien if (anon) 177390075Sobrien return tree_cons (NULL_TREE, field, anon); 1774132718Skan } 177518334Speter } 177618334Speter 177718334Speter /* Entire record is only anon unions. */ 177818334Speter if (bot > top) 177918334Speter return NULL_TREE; 178018334Speter 178118334Speter /* Restart the binary search, with new lower bound. */ 178218334Speter continue; 178318334Speter } 178418334Speter 178518334Speter if (DECL_NAME (field) == component) 178618334Speter break; 178718334Speter if (DECL_NAME (field) < component) 178818334Speter bot += half; 178918334Speter else 179018334Speter top = bot + half; 179118334Speter } 179218334Speter 179318334Speter if (DECL_NAME (field_array[bot]) == component) 179418334Speter field = field_array[bot]; 179518334Speter else if (DECL_NAME (field) != component) 179690075Sobrien return NULL_TREE; 179718334Speter } 179818334Speter else 179918334Speter { 180018334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 180118334Speter { 180290075Sobrien if (DECL_NAME (field) == NULL_TREE 180390075Sobrien && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 180490075Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)) 180518334Speter { 180690075Sobrien tree anon = lookup_field (field, component); 180750397Sobrien 180890075Sobrien if (anon) 180990075Sobrien return tree_cons (NULL_TREE, field, anon); 181018334Speter } 181118334Speter 181218334Speter if (DECL_NAME (field) == component) 181318334Speter break; 181418334Speter } 181590075Sobrien 181690075Sobrien if (field == NULL_TREE) 181790075Sobrien return NULL_TREE; 181818334Speter } 181918334Speter 182090075Sobrien return tree_cons (NULL_TREE, field, NULL_TREE); 182118334Speter} 182218334Speter 182318334Speter/* Make an expression to refer to the COMPONENT field of 182418334Speter structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */ 182518334Speter 182618334Spetertree 1827132718Skanbuild_component_ref (tree datum, tree component) 182818334Speter{ 182990075Sobrien tree type = TREE_TYPE (datum); 183090075Sobrien enum tree_code code = TREE_CODE (type); 183190075Sobrien tree field = NULL; 183290075Sobrien tree ref; 183318334Speter 1834169689Skan if (!objc_is_public (datum, component)) 1835169689Skan return error_mark_node; 1836169689Skan 1837260311Spfg /* APPLE LOCAL begin C* property (Radar 4436866) */ 1838260311Spfg /* APPLE LOCAL radar 5285911 */ 1839260311Spfg if ((ref = objc_build_property_reference_expr (datum, component))) 1840260311Spfg return ref; 1841260311Spfg /* APPLE LOCAL end C* property (Radar 4436866) */ 1842260311Spfg 184318334Speter /* See if there is a field or component with name COMPONENT. */ 184418334Speter 184518334Speter if (code == RECORD_TYPE || code == UNION_TYPE) 184618334Speter { 184790075Sobrien if (!COMPLETE_TYPE_P (type)) 184818334Speter { 1849117395Skan c_incomplete_type_error (NULL_TREE, type); 185018334Speter return error_mark_node; 185118334Speter } 185218334Speter 185390075Sobrien field = lookup_field (datum, component); 185418334Speter 185518334Speter if (!field) 185618334Speter { 1857169689Skan error ("%qT has no member named %qE", type, component); 185818334Speter return error_mark_node; 185918334Speter } 186018334Speter 186190075Sobrien /* Chain the COMPONENT_REFs if necessary down to the FIELD. 186290075Sobrien This might be better solved in future the way the C++ front 186390075Sobrien end does it - by giving the anonymous entities each a 186490075Sobrien separate name and type, and then have build_component_ref 186590075Sobrien recursively call itself. We can't do that here. */ 1866117395Skan do 186718334Speter { 186890075Sobrien tree subdatum = TREE_VALUE (field); 1869169689Skan int quals; 1870169689Skan tree subtype; 187190075Sobrien 187290075Sobrien if (TREE_TYPE (subdatum) == error_mark_node) 187390075Sobrien return error_mark_node; 187490075Sobrien 1875169689Skan quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum))); 1876169689Skan quals |= TYPE_QUALS (TREE_TYPE (datum)); 1877169689Skan subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals); 1878169689Skan 1879169689Skan ref = build3 (COMPONENT_REF, subtype, datum, subdatum, 1880169689Skan NULL_TREE); 1881260311Spfg /* APPLE LOCAL radar 4697411 */ 1882260311Spfg objc_volatilize_component_ref (ref, TREE_TYPE (subdatum)); 188390075Sobrien if (TREE_READONLY (datum) || TREE_READONLY (subdatum)) 188418334Speter TREE_READONLY (ref) = 1; 188590075Sobrien if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum)) 188618334Speter TREE_THIS_VOLATILE (ref) = 1; 188790075Sobrien 188890075Sobrien if (TREE_DEPRECATED (subdatum)) 188990075Sobrien warn_deprecated_use (subdatum); 189090075Sobrien 1891260014Spfg /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 1892260014Spfg if (TREE_UNAVAILABLE (subdatum)) 1893260014Spfg error_unavailable_use (subdatum); 1894260014Spfg /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 1895260014Spfg 189618334Speter datum = ref; 1897117395Skan 1898117395Skan field = TREE_CHAIN (field); 189918334Speter } 1900117395Skan while (field); 190118334Speter 190218334Speter return ref; 190318334Speter } 190418334Speter else if (code != ERROR_MARK) 1905169689Skan error ("request for member %qE in something not a structure or union", 1906169689Skan component); 190718334Speter 190818334Speter return error_mark_node; 190918334Speter} 191018334Speter 191118334Speter/* Given an expression PTR for a pointer, return an expression 191218334Speter for the value pointed to. 191318334Speter ERRORSTRING is the name of the operator to appear in error messages. */ 191418334Speter 191518334Spetertree 1916132718Skanbuild_indirect_ref (tree ptr, const char *errorstring) 191718334Speter{ 191890075Sobrien tree pointer = default_conversion (ptr); 191990075Sobrien tree type = TREE_TYPE (pointer); 192018334Speter 192118334Speter if (TREE_CODE (type) == POINTER_TYPE) 192218334Speter { 1923258501Spfg if (TREE_CODE (pointer) == CONVERT_EXPR 1924258501Spfg || TREE_CODE (pointer) == NOP_EXPR 1925258501Spfg || TREE_CODE (pointer) == VIEW_CONVERT_EXPR) 1926258501Spfg { 1927258501Spfg /* If a warning is issued, mark it to avoid duplicates from 1928258501Spfg the backend. This only needs to be done at 1929258501Spfg warn_strict_aliasing > 2. */ 1930258501Spfg if (warn_strict_aliasing > 2) 1931258501Spfg if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)), 1932258501Spfg type, TREE_OPERAND (pointer, 0))) 1933258501Spfg TREE_NO_WARNING (pointer) = 1; 1934258501Spfg } 1935258501Spfg 193618334Speter if (TREE_CODE (pointer) == ADDR_EXPR 193718334Speter && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 193818334Speter == TREE_TYPE (type))) 193918334Speter return TREE_OPERAND (pointer, 0); 194018334Speter else 194118334Speter { 194218334Speter tree t = TREE_TYPE (type); 1943169689Skan tree ref; 194418334Speter 1945169689Skan ref = build1 (INDIRECT_REF, t, pointer); 1946169689Skan 194790075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 194818334Speter { 194918334Speter error ("dereferencing pointer to incomplete type"); 195018334Speter return error_mark_node; 195118334Speter } 195290075Sobrien if (VOID_TYPE_P (t) && skip_evaluation == 0) 1953169689Skan warning (0, "dereferencing %<void *%> pointer"); 195418334Speter 195518334Speter /* We *must* set TREE_READONLY when dereferencing a pointer to const, 195618334Speter so that we get the proper error message if the result is used 195718334Speter to assign to. Also, &* is supposed to be a no-op. 195818334Speter And ANSI C seems to specify that the type of the result 195918334Speter should be the const type. */ 196018334Speter /* A de-reference of a pointer to const is not a const. It is valid 196118334Speter to change it via some other pointer. */ 196218334Speter TREE_READONLY (ref) = TYPE_READONLY (t); 196318334Speter TREE_SIDE_EFFECTS (ref) 1964132718Skan = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 196518334Speter TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 196618334Speter return ref; 196718334Speter } 196818334Speter } 196918334Speter else if (TREE_CODE (pointer) != ERROR_MARK) 1970259022Spfg error ("invalid type argument of %qs (have %qT)", errorstring, type); 197118334Speter return error_mark_node; 197218334Speter} 197318334Speter 197418334Speter/* This handles expressions of the form "a[i]", which denotes 197518334Speter an array reference. 197618334Speter 197718334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 197818334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 197918334Speter This avoids forcing the array out of registers, and can work on 198018334Speter arrays that are not lvalues (for example, members of structures returned 198118334Speter by functions). */ 198218334Speter 198318334Spetertree 1984132718Skanbuild_array_ref (tree array, tree index) 198518334Speter{ 1986169689Skan bool swapped = false; 198718334Speter if (TREE_TYPE (array) == error_mark_node 198818334Speter || TREE_TYPE (index) == error_mark_node) 198918334Speter return error_mark_node; 199018334Speter 1991169689Skan if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1992169689Skan && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 199318334Speter { 1994169689Skan tree temp; 1995169689Skan if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1996169689Skan && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 199718334Speter { 1998169689Skan error ("subscripted value is neither array nor pointer"); 199918334Speter return error_mark_node; 200018334Speter } 2001169689Skan temp = array; 2002169689Skan array = index; 2003169689Skan index = temp; 2004169689Skan swapped = true; 2005169689Skan } 200618334Speter 2007169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 2008169689Skan { 2009169689Skan error ("array subscript is not an integer"); 2010169689Skan return error_mark_node; 2011169689Skan } 2012169689Skan 2013169689Skan if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 2014169689Skan { 2015169689Skan error ("subscripted value is pointer to function"); 2016169689Skan return error_mark_node; 2017169689Skan } 2018169689Skan 2019169689Skan /* ??? Existing practice has been to warn only when the char 2020169689Skan index is syntactically the index, not for char[array]. */ 2021169689Skan if (!swapped) 2022169689Skan warn_array_subscript_with_type_char (index); 2023169689Skan 2024169689Skan /* Apply default promotions *after* noticing character types. */ 2025169689Skan index = default_conversion (index); 2026169689Skan 2027169689Skan gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 2028169689Skan 2029169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 2030169689Skan { 2031169689Skan tree rval, type; 2032169689Skan 203318334Speter /* An array that is indexed by a non-constant 203418334Speter cannot be stored in a register; we must be able to do 203518334Speter address arithmetic on its address. 203618334Speter Likewise an array of elements of variable size. */ 203718334Speter if (TREE_CODE (index) != INTEGER_CST 203890075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 203918334Speter && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 204018334Speter { 2041117395Skan if (!c_mark_addressable (array)) 204218334Speter return error_mark_node; 204318334Speter } 204418334Speter /* An array that is indexed by a constant value which is not within 204518334Speter the array bounds cannot be stored in a register either; because we 204618334Speter would get a crash in store_bit_field/extract_bit_field when trying 204718334Speter to access a non-existent part of the register. */ 204818334Speter if (TREE_CODE (index) == INTEGER_CST 2049169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 2050169689Skan && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 205118334Speter { 2052117395Skan if (!c_mark_addressable (array)) 205318334Speter return error_mark_node; 205418334Speter } 205518334Speter 205618334Speter if (pedantic) 205718334Speter { 205818334Speter tree foo = array; 205918334Speter while (TREE_CODE (foo) == COMPONENT_REF) 206018334Speter foo = TREE_OPERAND (foo, 0); 2061169689Skan if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2062169689Skan pedwarn ("ISO C forbids subscripting %<register%> array"); 2063169689Skan else if (!flag_isoc99 && !lvalue_p (foo)) 2064117395Skan pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 206518334Speter } 206618334Speter 2067169689Skan type = TREE_TYPE (TREE_TYPE (array)); 2068169689Skan if (TREE_CODE (type) != ARRAY_TYPE) 2069169689Skan type = TYPE_MAIN_VARIANT (type); 2070169689Skan rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 207118334Speter /* Array ref is const/volatile if the array elements are 2072169689Skan or if the array is. */ 207318334Speter TREE_READONLY (rval) 207418334Speter |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 207518334Speter | TREE_READONLY (array)); 207618334Speter TREE_SIDE_EFFECTS (rval) 207718334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 207818334Speter | TREE_SIDE_EFFECTS (array)); 207918334Speter TREE_THIS_VOLATILE (rval) 208018334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 208118334Speter /* This was added by rms on 16 Nov 91. 2082132718Skan It fixes vol struct foo *a; a->elts[1] 208318334Speter in an inline function. 208418334Speter Hope it doesn't break something else. */ 208518334Speter | TREE_THIS_VOLATILE (array)); 208618334Speter return require_complete_type (fold (rval)); 208718334Speter } 2088169689Skan else 2089169689Skan { 2090169689Skan tree ar = default_conversion (array); 209118334Speter 2092169689Skan if (ar == error_mark_node) 2093169689Skan return ar; 209418334Speter 2095169689Skan gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2096169689Skan gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 209750397Sobrien 2098169689Skan return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2099169689Skan "array indexing"); 2100169689Skan } 210118334Speter} 210218334Speter 210390075Sobrien/* Build an external reference to identifier ID. FUN indicates 2104169689Skan whether this will be used for a function call. LOC is the source 2105169689Skan location of the identifier. */ 210690075Sobrientree 2107169689Skanbuild_external_ref (tree id, int fun, location_t loc) 210890075Sobrien{ 210990075Sobrien tree ref; 211090075Sobrien tree decl = lookup_name (id); 211190075Sobrien 2112169689Skan /* In Objective-C, an instance variable (ivar) may be preferred to 2113169689Skan whatever lookup_name() found. */ 2114169689Skan decl = objc_lookup_ivar (decl, id); 2115260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks (C++ ci) */ 2116132718Skan if (decl && decl != error_mark_node) 2117260311Spfg { 2118260311Spfg if (cur_block 2119260311Spfg && (TREE_CODE (decl) == VAR_DECL 2120260311Spfg || TREE_CODE (decl) == PARM_DECL) 2121260311Spfg && !lookup_name_in_block (id, &decl)) 2122260311Spfg { 2123260311Spfg /* APPLE LOCAL begin radar 5803005 (C++ ci) */ 2124260311Spfg bool gdecl; 2125260311Spfg /* We are referencing a variable inside a block whose declaration 2126260311Spfg is outside. */ 2127260311Spfg gcc_assert (decl && 2128260311Spfg (TREE_CODE (decl) == VAR_DECL 2129260311Spfg || TREE_CODE (decl) == PARM_DECL)); 2130260311Spfg gdecl = (TREE_CODE (decl) == VAR_DECL && 2131260311Spfg /* APPLE LOCAL radar 6177162 */ 2132260311Spfg (DECL_EXTERNAL (decl) || TREE_STATIC (decl))); 2133260311Spfg /* Treat all 'global' variables as 'byref' by default. */ 2134260311Spfg /* APPLE LOCAL begin radar 6014138 (C++ ci) */ 2135260311Spfg if (gdecl || (TREE_CODE (decl) == VAR_DECL && COPYABLE_BYREF_LOCAL_VAR (decl))) 2136260311Spfg /* APPLE LOCAL end radar 6014138 (C++ ci) */ 2137260311Spfg { 2138260311Spfg /* APPLE LOCAL begin radar 5803600 (C++ ci) */ 2139260311Spfg /* byref globals are directly accessed. */ 2140260311Spfg /* APPLE LOCAL begin radar 7760213 */ 2141260311Spfg if (!gdecl) { 2142260311Spfg if (HasByrefArray(TREE_TYPE (decl))) 2143260311Spfg error ("cannot access __block variable of array type inside block"); 2144260311Spfg /* build a decl for the byref variable. */ 2145260311Spfg decl = build_block_byref_decl (id, decl, decl); 2146260311Spfg } 2147260311Spfg /* APPLE LOCAL end radar 7760213 */ 2148260311Spfg else 2149260311Spfg add_block_global_byref_list (decl); 2150260311Spfg } 2151260311Spfg else 2152260311Spfg { 2153260311Spfg /* 'byref' globals are never copied-in. So, do not add 2154260311Spfg them to the copied-in list. */ 2155260311Spfg if (!in_block_global_byref_list (decl)) { 2156260311Spfg /* APPLE LOCAL begin radar 7721728 */ 2157260311Spfg if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 2158260311Spfg error ("cannot access copied-in variable of array type inside block"); 2159260311Spfg /* APPLE LOCAL end radar 7721728 */ 2160260311Spfg /* build a new decl node. set its type to 'const' type 2161260311Spfg of the old decl. */ 2162260311Spfg decl = build_block_ref_decl (id, decl); 2163260311Spfg } 2164260311Spfg /* APPLE LOCAL end radar 5803600 (C++ ci) */ 2165260311Spfg /* APPLE LOCAL end radar 5803005 (C++ ci) */ 2166260311Spfg } 2167260311Spfg } 2168260311Spfg ref = decl; 2169260311Spfg } 2170260311Spfg /* APPLE LOCAL end radar 5732232 - blocks (C++ ci) */ 2171132718Skan else if (fun) 2172132718Skan /* Implicit function declaration. */ 2173132718Skan ref = implicitly_declare (id); 2174132718Skan else if (decl == error_mark_node) 2175132718Skan /* Don't complain about something that's already been 2176132718Skan complained about. */ 2177132718Skan return error_mark_node; 2178132718Skan else 2179132718Skan { 2180169689Skan undeclared_variable (id, loc); 2181132718Skan return error_mark_node; 2182132718Skan } 218390075Sobrien 218490075Sobrien if (TREE_TYPE (ref) == error_mark_node) 218590075Sobrien return error_mark_node; 218690075Sobrien 2187132718Skan if (TREE_DEPRECATED (ref)) 2188132718Skan warn_deprecated_use (ref); 2189132718Skan 2190260014Spfg /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 2191260014Spfg if (TREE_UNAVAILABLE (ref)) 2192260014Spfg error_unavailable_use (ref); 2193260014Spfg /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 2194260014Spfg 2195103445Skan if (!skip_evaluation) 2196103445Skan assemble_external (ref); 219790075Sobrien TREE_USED (ref) = 1; 219890075Sobrien 2199169689Skan if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2200169689Skan { 2201169689Skan if (!in_sizeof && !in_typeof) 2202169689Skan C_DECL_USED (ref) = 1; 2203169689Skan else if (DECL_INITIAL (ref) == 0 2204169689Skan && DECL_EXTERNAL (ref) 2205169689Skan && !TREE_PUBLIC (ref)) 2206169689Skan record_maybe_used_decl (ref); 2207169689Skan } 2208169689Skan 220990075Sobrien if (TREE_CODE (ref) == CONST_DECL) 221090075Sobrien { 2211169689Skan used_types_insert (TREE_TYPE (ref)); 221290075Sobrien ref = DECL_INITIAL (ref); 221390075Sobrien TREE_CONSTANT (ref) = 1; 2214169689Skan TREE_INVARIANT (ref) = 1; 221590075Sobrien } 2216117395Skan else if (current_function_decl != 0 2217132718Skan && !DECL_FILE_SCOPE_P (current_function_decl) 2218117395Skan && (TREE_CODE (ref) == VAR_DECL 2219117395Skan || TREE_CODE (ref) == PARM_DECL 2220117395Skan || TREE_CODE (ref) == FUNCTION_DECL)) 2221117395Skan { 2222117395Skan tree context = decl_function_context (ref); 2223132718Skan 2224117395Skan if (context != 0 && context != current_function_decl) 2225117395Skan DECL_NONLOCAL (ref) = 1; 2226117395Skan } 2227189824Sdas /* C99 6.7.4p3: An inline definition of a function with external 2228189824Sdas linkage ... shall not contain a reference to an identifier with 2229189824Sdas internal linkage. */ 2230189824Sdas else if (current_function_decl != 0 2231189824Sdas && DECL_DECLARED_INLINE_P (current_function_decl) 2232189824Sdas && DECL_EXTERNAL (current_function_decl) 2233189824Sdas && VAR_OR_FUNCTION_DECL_P (ref) 2234189824Sdas && DECL_FILE_SCOPE_P (ref) 2235189824Sdas && pedantic 2236189824Sdas && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) 2237189824Sdas && ! TREE_PUBLIC (ref)) 2238189824Sdas pedwarn ("%H%qD is static but used in inline function %qD " 2239189824Sdas "which is not static", &loc, ref, current_function_decl); 224090075Sobrien 224190075Sobrien return ref; 224290075Sobrien} 224390075Sobrien 2244169689Skan/* Record details of decls possibly used inside sizeof or typeof. */ 2245169689Skanstruct maybe_used_decl 2246169689Skan{ 2247169689Skan /* The decl. */ 2248169689Skan tree decl; 2249169689Skan /* The level seen at (in_sizeof + in_typeof). */ 2250169689Skan int level; 2251169689Skan /* The next one at this level or above, or NULL. */ 2252169689Skan struct maybe_used_decl *next; 2253169689Skan}; 2254169689Skan 2255169689Skanstatic struct maybe_used_decl *maybe_used_decls; 2256169689Skan 2257169689Skan/* Record that DECL, an undefined static function reference seen 2258169689Skan inside sizeof or typeof, might be used if the operand of sizeof is 2259169689Skan a VLA type or the operand of typeof is a variably modified 2260169689Skan type. */ 2261169689Skan 2262169689Skanstatic void 2263169689Skanrecord_maybe_used_decl (tree decl) 2264169689Skan{ 2265169689Skan struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2266169689Skan t->decl = decl; 2267169689Skan t->level = in_sizeof + in_typeof; 2268169689Skan t->next = maybe_used_decls; 2269169689Skan maybe_used_decls = t; 2270169689Skan} 2271169689Skan 2272169689Skan/* Pop the stack of decls possibly used inside sizeof or typeof. If 2273169689Skan USED is false, just discard them. If it is true, mark them used 2274169689Skan (if no longer inside sizeof or typeof) or move them to the next 2275169689Skan level up (if still inside sizeof or typeof). */ 2276169689Skan 2277169689Skanvoid 2278169689Skanpop_maybe_used (bool used) 2279169689Skan{ 2280169689Skan struct maybe_used_decl *p = maybe_used_decls; 2281169689Skan int cur_level = in_sizeof + in_typeof; 2282169689Skan while (p && p->level > cur_level) 2283169689Skan { 2284169689Skan if (used) 2285169689Skan { 2286169689Skan if (cur_level == 0) 2287169689Skan C_DECL_USED (p->decl) = 1; 2288169689Skan else 2289169689Skan p->level = cur_level; 2290169689Skan } 2291169689Skan p = p->next; 2292169689Skan } 2293169689Skan if (!used || cur_level == 0) 2294169689Skan maybe_used_decls = p; 2295169689Skan} 2296169689Skan 2297169689Skan/* Return the result of sizeof applied to EXPR. */ 2298169689Skan 2299169689Skanstruct c_expr 2300169689Skanc_expr_sizeof_expr (struct c_expr expr) 2301169689Skan{ 2302169689Skan struct c_expr ret; 2303169689Skan if (expr.value == error_mark_node) 2304169689Skan { 2305169689Skan ret.value = error_mark_node; 2306169689Skan ret.original_code = ERROR_MARK; 2307169689Skan pop_maybe_used (false); 2308169689Skan } 2309169689Skan else 2310169689Skan { 2311169689Skan ret.value = c_sizeof (TREE_TYPE (expr.value)); 2312169689Skan ret.original_code = ERROR_MARK; 2313169689Skan if (c_vla_type_p (TREE_TYPE (expr.value))) 2314169689Skan { 2315169689Skan /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2316169689Skan ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2317169689Skan } 2318169689Skan pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2319169689Skan } 2320169689Skan return ret; 2321169689Skan} 2322169689Skan 2323169689Skan/* Return the result of sizeof applied to T, a structure for the type 2324169689Skan name passed to sizeof (rather than the type itself). */ 2325169689Skan 2326169689Skanstruct c_expr 2327169689Skanc_expr_sizeof_type (struct c_type_name *t) 2328169689Skan{ 2329169689Skan tree type; 2330169689Skan struct c_expr ret; 2331169689Skan type = groktypename (t); 2332169689Skan ret.value = c_sizeof (type); 2333169689Skan ret.original_code = ERROR_MARK; 2334169689Skan pop_maybe_used (type != error_mark_node 2335169689Skan ? C_TYPE_VARIABLE_SIZE (type) : false); 2336169689Skan return ret; 2337169689Skan} 2338169689Skan 233918334Speter/* Build a function call to function FUNCTION with parameters PARAMS. 234018334Speter PARAMS is a list--a chain of TREE_LIST nodes--in which the 234118334Speter TREE_VALUE of each node is a parameter-expression. 234218334Speter FUNCTION's data type may be a function type or a pointer-to-function. */ 234318334Speter 234418334Spetertree 2345132718Skanbuild_function_call (tree function, tree params) 234618334Speter{ 234790075Sobrien tree fntype, fundecl = 0; 234890075Sobrien tree coerced_params; 2349132718Skan tree name = NULL_TREE, result; 2350132718Skan tree tem; 235118334Speter 235218334Speter /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 235318334Speter STRIP_TYPE_NOPS (function); 235418334Speter 235518334Speter /* Convert anything with function type to a pointer-to-function. */ 235618334Speter if (TREE_CODE (function) == FUNCTION_DECL) 235718334Speter { 2358169689Skan /* Implement type-directed function overloading for builtins. 2359169689Skan resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2360169689Skan handle all the type checking. The result is a complete expression 2361169689Skan that implements this function call. */ 2362169689Skan tem = resolve_overloaded_builtin (function, params); 2363169689Skan if (tem) 2364169689Skan return tem; 2365169689Skan 236618334Speter name = DECL_NAME (function); 236718334Speter fundecl = function; 236818334Speter } 2369169689Skan if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2370169689Skan function = function_to_pointer_conversion (function); 237118334Speter 2372169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2373169689Skan expressions, like those used for ObjC messenger dispatches. */ 2374169689Skan function = objc_rewrite_function_call (function, params); 2375169689Skan 237618334Speter fntype = TREE_TYPE (function); 237718334Speter 237818334Speter if (TREE_CODE (fntype) == ERROR_MARK) 237918334Speter return error_mark_node; 2380260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 2381260311Spfg if (!((TREE_CODE (fntype) == POINTER_TYPE 2382260311Spfg || TREE_CODE (fntype) == BLOCK_POINTER_TYPE) 2383260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 238418334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 238518334Speter { 2386169689Skan error ("called object %qE is not a function", function); 238718334Speter return error_mark_node; 238818334Speter } 238918334Speter 239096263Sobrien if (fundecl && TREE_THIS_VOLATILE (fundecl)) 239196263Sobrien current_function_returns_abnormally = 1; 239296263Sobrien 239318334Speter /* fntype now gets the type of function pointed to. */ 239418334Speter fntype = TREE_TYPE (fntype); 239518334Speter 2396132718Skan /* Check that the function is called through a compatible prototype. 2397132718Skan If it is not, replace the call by a trap, wrapped up in a compound 2398132718Skan expression if necessary. This has the nice side-effect to prevent 2399132718Skan the tree-inliner from generating invalid assignment trees which may 2400169689Skan blow up in the RTL expander later. */ 2401169689Skan if ((TREE_CODE (function) == NOP_EXPR 2402169689Skan || TREE_CODE (function) == CONVERT_EXPR) 2403132718Skan && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2404132718Skan && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2405169689Skan && !comptypes (fntype, TREE_TYPE (tem))) 2406132718Skan { 2407132718Skan tree return_type = TREE_TYPE (fntype); 2408132718Skan tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2409132718Skan NULL_TREE); 2410132718Skan 2411132718Skan /* This situation leads to run-time undefined behavior. We can't, 2412132718Skan therefore, simply error unless we can prove that all possible 2413132718Skan executions of the program must execute the code. */ 2414169689Skan warning (0, "function called through a non-compatible type"); 2415132718Skan 2416132718Skan /* We can, however, treat "undefined" any way we please. 2417132718Skan Call abort to encourage the user to fix the program. */ 2418132718Skan inform ("if this code is reached, the program will abort"); 2419132718Skan 2420132718Skan if (VOID_TYPE_P (return_type)) 2421132718Skan return trap; 2422132718Skan else 2423132718Skan { 2424132718Skan tree rhs; 2425132718Skan 2426132718Skan if (AGGREGATE_TYPE_P (return_type)) 2427132718Skan rhs = build_compound_literal (return_type, 2428169689Skan build_constructor (return_type, 0)); 2429132718Skan else 2430169689Skan rhs = fold_convert (return_type, integer_zero_node); 2431132718Skan 2432169689Skan return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2433132718Skan } 2434132718Skan } 2435132718Skan 243618334Speter /* Convert the parameters to the types declared in the 243718334Speter function prototype, or apply default promotions. */ 243818334Speter 243918334Speter coerced_params 2440169689Skan = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 244118334Speter 2442169689Skan if (coerced_params == error_mark_node) 2443169689Skan return error_mark_node; 2444169689Skan 2445117395Skan /* Check that the arguments to the function are valid. */ 244618334Speter 2447169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2448169689Skan TYPE_ARG_TYPES (fntype)); 244918334Speter 2450260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 2451260311Spfg if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2452260311Spfg result = build_block_call (fntype, function, coerced_params); 2453260311Spfg else 2454260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 2455132718Skan if (require_constant_value) 2456132718Skan { 2457169689Skan result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2458169689Skan function, coerced_params, NULL_TREE); 2459132718Skan 2460132718Skan if (TREE_CONSTANT (result) 2461132718Skan && (name == NULL_TREE 2462132718Skan || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2463132718Skan pedwarn_init ("initializer element is not constant"); 2464132718Skan } 2465132718Skan else 2466169689Skan result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2467169689Skan function, coerced_params, NULL_TREE); 2468132718Skan 246990075Sobrien if (VOID_TYPE_P (TREE_TYPE (result))) 247090075Sobrien return result; 247190075Sobrien return require_complete_type (result); 247218334Speter} 247318334Speter 247418334Speter/* Convert the argument expressions in the list VALUES 247518334Speter to the types in the list TYPELIST. The result is a list of converted 2476169689Skan argument expressions, unless there are too few arguments in which 2477169689Skan case it is error_mark_node. 247818334Speter 247918334Speter If TYPELIST is exhausted, or when an element has NULL as its type, 248018334Speter perform the default conversions. 248118334Speter 248218334Speter PARMLIST is the chain of parm decls for the function being called. 248318334Speter It may be 0, if that info is not available. 248418334Speter It is used only for generating error messages. 248518334Speter 2486169689Skan FUNCTION is a tree for the called function. It is used only for 2487169689Skan error messages, where it is formatted with %qE. 248818334Speter 248918334Speter This is also where warnings about wrong number of args are generated. 249018334Speter 249118334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 249218334Speter with the elements of the list in the TREE_VALUE slots of those nodes. */ 249318334Speter 249418334Speterstatic tree 2495169689Skanconvert_arguments (tree typelist, tree values, tree function, tree fundecl) 249618334Speter{ 249790075Sobrien tree typetail, valtail; 249890075Sobrien tree result = NULL; 249918334Speter int parmnum; 2500169689Skan tree selector; 250118334Speter 2502169689Skan /* Change pointer to function to the function itself for 2503169689Skan diagnostics. */ 2504169689Skan if (TREE_CODE (function) == ADDR_EXPR 2505169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2506169689Skan function = TREE_OPERAND (function, 0); 2507169689Skan 2508169689Skan /* Handle an ObjC selector specially for diagnostics. */ 2509169689Skan selector = objc_message_selector (); 2510169689Skan 251118334Speter /* Scan the given expressions and types, producing individual 251218334Speter converted arguments and pushing them on RESULT in reverse order. */ 251318334Speter 251418334Speter for (valtail = values, typetail = typelist, parmnum = 0; 251518334Speter valtail; 251618334Speter valtail = TREE_CHAIN (valtail), parmnum++) 251718334Speter { 251890075Sobrien tree type = typetail ? TREE_VALUE (typetail) : 0; 251990075Sobrien tree val = TREE_VALUE (valtail); 2520169689Skan tree rname = function; 2521169689Skan int argnum = parmnum + 1; 2522169689Skan const char *invalid_func_diag; 252318334Speter 252418334Speter if (type == void_type_node) 252518334Speter { 2526260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 2527260311Spfg if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2528260311Spfg { 2529260311Spfg error ("too many arguments to block call"); 2530260311Spfg break; 2531260311Spfg } 2532260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 2533260311Spfg /* APPLE LOCAL begin radar 4491608 */ 2534260311Spfg error ("too many arguments to function %qE", selector ? selector 2535260311Spfg : function); 2536260311Spfg /* APPLE LOCAL end radar 4491608 */ 253718334Speter break; 253818334Speter } 253918334Speter 2540169689Skan if (selector && argnum > 2) 2541169689Skan { 2542169689Skan rname = selector; 2543169689Skan argnum -= 2; 2544169689Skan } 254518334Speter 2546169689Skan STRIP_TYPE_NOPS (val); 254718334Speter 254818334Speter val = require_complete_type (val); 254918334Speter 255018334Speter if (type != 0) 255118334Speter { 255218334Speter /* Formal parm type is specified by a function prototype. */ 255318334Speter tree parmval; 255418334Speter 2555169689Skan if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 255618334Speter { 255718334Speter error ("type of formal parameter %d is incomplete", parmnum + 1); 255818334Speter parmval = val; 255918334Speter } 256018334Speter else 256118334Speter { 256218334Speter /* Optionally warn about conversions that 256318334Speter differ from the default conversions. */ 256490075Sobrien if (warn_conversion || warn_traditional) 256518334Speter { 2566169689Skan unsigned int formal_prec = TYPE_PRECISION (type); 256718334Speter 256818334Speter if (INTEGRAL_TYPE_P (type) 256918334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2570169689Skan warning (0, "passing argument %d of %qE as integer " 2571169689Skan "rather than floating due to prototype", 2572169689Skan argnum, rname); 257390075Sobrien if (INTEGRAL_TYPE_P (type) 257490075Sobrien && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2575169689Skan warning (0, "passing argument %d of %qE as integer " 2576169689Skan "rather than complex due to prototype", 2577169689Skan argnum, rname); 257818334Speter else if (TREE_CODE (type) == COMPLEX_TYPE 257918334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2580169689Skan warning (0, "passing argument %d of %qE as complex " 2581169689Skan "rather than floating due to prototype", 2582169689Skan argnum, rname); 258318334Speter else if (TREE_CODE (type) == REAL_TYPE 258418334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2585169689Skan warning (0, "passing argument %d of %qE as floating " 2586169689Skan "rather than integer due to prototype", 2587169689Skan argnum, rname); 258890075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE 258990075Sobrien && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2590169689Skan warning (0, "passing argument %d of %qE as complex " 2591169689Skan "rather than integer due to prototype", 2592169689Skan argnum, rname); 259318334Speter else if (TREE_CODE (type) == REAL_TYPE 259418334Speter && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2595169689Skan warning (0, "passing argument %d of %qE as floating " 2596169689Skan "rather than complex due to prototype", 2597169689Skan argnum, rname); 259818334Speter /* ??? At some point, messages should be written about 259918334Speter conversions between complex types, but that's too messy 260018334Speter to do now. */ 260118334Speter else if (TREE_CODE (type) == REAL_TYPE 260218334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 260318334Speter { 260418334Speter /* Warn if any argument is passed as `float', 260518334Speter since without a prototype it would be `double'. */ 2606169689Skan if (formal_prec == TYPE_PRECISION (float_type_node) 2607169689Skan && type != dfloat32_type_node) 2608169689Skan warning (0, "passing argument %d of %qE as %<float%> " 2609169689Skan "rather than %<double%> due to prototype", 2610169689Skan argnum, rname); 2611169689Skan 2612169689Skan /* Warn if mismatch between argument and prototype 2613169689Skan for decimal float types. Warn of conversions with 2614169689Skan binary float types and of precision narrowing due to 2615169689Skan prototype. */ 2616169689Skan else if (type != TREE_TYPE (val) 2617169689Skan && (type == dfloat32_type_node 2618169689Skan || type == dfloat64_type_node 2619169689Skan || type == dfloat128_type_node 2620169689Skan || TREE_TYPE (val) == dfloat32_type_node 2621169689Skan || TREE_TYPE (val) == dfloat64_type_node 2622169689Skan || TREE_TYPE (val) == dfloat128_type_node) 2623169689Skan && (formal_prec 2624169689Skan <= TYPE_PRECISION (TREE_TYPE (val)) 2625169689Skan || (type == dfloat128_type_node 2626169689Skan && (TREE_TYPE (val) 2627169689Skan != dfloat64_type_node 2628169689Skan && (TREE_TYPE (val) 2629169689Skan != dfloat32_type_node))) 2630169689Skan || (type == dfloat64_type_node 2631169689Skan && (TREE_TYPE (val) 2632169689Skan != dfloat32_type_node)))) 2633169689Skan warning (0, "passing argument %d of %qE as %qT " 2634169689Skan "rather than %qT due to prototype", 2635169689Skan argnum, rname, type, TREE_TYPE (val)); 2636169689Skan 263718334Speter } 263890075Sobrien /* Detect integer changing in width or signedness. 263990075Sobrien These warnings are only activated with 264090075Sobrien -Wconversion, not with -Wtraditional. */ 264190075Sobrien else if (warn_conversion && INTEGRAL_TYPE_P (type) 264218334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 264318334Speter { 264418334Speter tree would_have_been = default_conversion (val); 264518334Speter tree type1 = TREE_TYPE (would_have_been); 264618334Speter 264718334Speter if (TREE_CODE (type) == ENUMERAL_TYPE 264890075Sobrien && (TYPE_MAIN_VARIANT (type) 264990075Sobrien == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 265018334Speter /* No warning if function asks for enum 265118334Speter and the actual arg is that enum type. */ 265218334Speter ; 265318334Speter else if (formal_prec != TYPE_PRECISION (type1)) 2654169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2655169689Skan "with different width due to prototype", 2656169689Skan argnum, rname); 2657169689Skan else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 265818334Speter ; 265918334Speter /* Don't complain if the formal parameter type 266018334Speter is an enum, because we can't tell now whether 266118334Speter the value was an enum--even the same enum. */ 266218334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE) 266318334Speter ; 266418334Speter else if (TREE_CODE (val) == INTEGER_CST 266518334Speter && int_fits_type_p (val, type)) 266618334Speter /* Change in signedness doesn't matter 266718334Speter if a constant value is unaffected. */ 266818334Speter ; 266918334Speter /* If the value is extended from a narrower 267018334Speter unsigned type, it doesn't matter whether we 267118334Speter pass it as signed or unsigned; the value 267218334Speter certainly is the same either way. */ 267318334Speter else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2674169689Skan && TYPE_UNSIGNED (TREE_TYPE (val))) 267518334Speter ; 2676169689Skan else if (TYPE_UNSIGNED (type)) 2677169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2678169689Skan "as unsigned due to prototype", 2679169689Skan argnum, rname); 268018334Speter else 2681169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2682169689Skan "as signed due to prototype", argnum, rname); 268318334Speter } 268418334Speter } 268518334Speter 2686169689Skan parmval = convert_for_assignment (type, val, ic_argpass, 2687169689Skan fundecl, function, 2688169689Skan parmnum + 1); 2689132718Skan 2690132718Skan if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 269190075Sobrien && INTEGRAL_TYPE_P (type) 269218334Speter && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 269318334Speter parmval = default_conversion (parmval); 269418334Speter } 269518334Speter result = tree_cons (NULL_TREE, parmval, result); 269618334Speter } 269718334Speter else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2698169689Skan && (TYPE_PRECISION (TREE_TYPE (val)) 2699169689Skan < TYPE_PRECISION (double_type_node)) 2700169689Skan && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 270118334Speter /* Convert `float' to `double'. */ 270218334Speter result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2703169689Skan else if ((invalid_func_diag = 2704169689Skan targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2705169689Skan { 2706259666Spfg error (invalid_func_diag, ""); 2707169689Skan return error_mark_node; 2708169689Skan } 270918334Speter else 271018334Speter /* Convert `short' and `char' to full-size `int'. */ 271118334Speter result = tree_cons (NULL_TREE, default_conversion (val), result); 271218334Speter 271318334Speter if (typetail) 271418334Speter typetail = TREE_CHAIN (typetail); 271518334Speter } 271618334Speter 271718334Speter if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 271818334Speter { 2719260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 2720260311Spfg if (TREE_CODE (TREE_TYPE (function)) == BLOCK_POINTER_TYPE) 2721260311Spfg error ("too few arguments to block %qE", function); 2722260311Spfg else 2723260311Spfg error ("too few arguments to function %qE", function); 2724260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 2725169689Skan return error_mark_node; 272618334Speter } 272718334Speter 272818334Speter return nreverse (result); 272918334Speter} 273018334Speter 2731169689Skan/* This is the entry point used by the parser to build unary operators 2732169689Skan in the input. CODE, a tree_code, specifies the unary operator, and 2733169689Skan ARG is the operand. For unary plus, the C parser currently uses 2734169689Skan CONVERT_EXPR for code. */ 273518334Speter 2736169689Skanstruct c_expr 2737169689Skanparser_build_unary_op (enum tree_code code, struct c_expr arg) 273818334Speter{ 2739169689Skan struct c_expr result; 274018334Speter 2741169689Skan result.original_code = ERROR_MARK; 2742169689Skan result.value = build_unary_op (code, arg.value, 0); 2743258731Spfg 2744258731Spfg if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value)) 2745258731Spfg overflow_warning (result.value); 2746258731Spfg 2747169689Skan return result; 2748169689Skan} 274918334Speter 2750169689Skan/* This is the entry point used by the parser to build binary operators 2751169689Skan in the input. CODE, a tree_code, specifies the binary operator, and 2752169689Skan ARG1 and ARG2 are the operands. In addition to constructing the 2753169689Skan expression, we check for operands that were written with other binary 2754169689Skan operators in a way that is likely to confuse the user. */ 275590075Sobrien 2756169689Skanstruct c_expr 2757169689Skanparser_build_binary_op (enum tree_code code, struct c_expr arg1, 2758169689Skan struct c_expr arg2) 2759169689Skan{ 2760169689Skan struct c_expr result; 276118334Speter 2762169689Skan enum tree_code code1 = arg1.original_code; 2763169689Skan enum tree_code code2 = arg2.original_code; 2764169689Skan 2765169689Skan result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2766169689Skan result.original_code = code; 2767169689Skan 2768169689Skan if (TREE_CODE (result.value) == ERROR_MARK) 2769169689Skan return result; 2770169689Skan 277118334Speter /* Check for cases such as x+y<<z which users are likely 2772169689Skan to misinterpret. */ 277318334Speter if (warn_parentheses) 2774258081Spfg warn_about_parentheses (code, code1, code2); 277518334Speter 2776169689Skan /* Warn about comparisons against string literals, with the exception 2777169689Skan of testing for equality or inequality of a string literal with NULL. */ 2778169689Skan if (code == EQ_EXPR || code == NE_EXPR) 277918334Speter { 2780169689Skan if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2781169689Skan || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2782169689Skan warning (OPT_Waddress, 2783169689Skan "comparison with string literal results in unspecified behaviour"); 278418334Speter } 2785169689Skan else if (TREE_CODE_CLASS (code) == tcc_comparison 2786169689Skan && (code1 == STRING_CST || code2 == STRING_CST)) 2787169689Skan warning (OPT_Waddress, 2788169689Skan "comparison with string literal results in unspecified behaviour"); 278918334Speter 2790258731Spfg if (TREE_OVERFLOW_P (result.value) 2791258731Spfg && !TREE_OVERFLOW_P (arg1.value) 2792258731Spfg && !TREE_OVERFLOW_P (arg2.value)) 2793258731Spfg overflow_warning (result.value); 2794169689Skan 279518334Speter return result; 279618334Speter} 279718334Speter 279818334Speter/* Return a tree for the difference of pointers OP0 and OP1. 279918334Speter The resulting tree has type int. */ 280018334Speter 280118334Speterstatic tree 2802132718Skanpointer_diff (tree op0, tree op1) 280318334Speter{ 280418334Speter tree restype = ptrdiff_type_node; 280518334Speter 280618334Speter tree target_type = TREE_TYPE (TREE_TYPE (op0)); 280790075Sobrien tree con0, con1, lit0, lit1; 280890075Sobrien tree orig_op1 = op1; 280918334Speter 281018334Speter if (pedantic || warn_pointer_arith) 281118334Speter { 281218334Speter if (TREE_CODE (target_type) == VOID_TYPE) 2813169689Skan pedwarn ("pointer of type %<void *%> used in subtraction"); 281418334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 281518334Speter pedwarn ("pointer to a function used in subtraction"); 281618334Speter } 281718334Speter 281890075Sobrien /* If the conversion to ptrdiff_type does anything like widening or 281990075Sobrien converting a partial to an integral mode, we get a convert_expression 282090075Sobrien that is in the way to do any simplifications. 282190075Sobrien (fold-const.c doesn't know that the extra bits won't be needed. 282290075Sobrien split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 282390075Sobrien different mode in place.) 282490075Sobrien So first try to find a common term here 'by hand'; we want to cover 282590075Sobrien at least the cases that occur in legal static initializers. */ 2826169689Skan if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2827169689Skan && (TYPE_PRECISION (TREE_TYPE (op0)) 2828169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2829169689Skan con0 = TREE_OPERAND (op0, 0); 2830169689Skan else 2831169689Skan con0 = op0; 2832169689Skan if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2833169689Skan && (TYPE_PRECISION (TREE_TYPE (op1)) 2834169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2835169689Skan con1 = TREE_OPERAND (op1, 0); 2836169689Skan else 2837169689Skan con1 = op1; 283890075Sobrien 283990075Sobrien if (TREE_CODE (con0) == PLUS_EXPR) 284090075Sobrien { 284190075Sobrien lit0 = TREE_OPERAND (con0, 1); 284290075Sobrien con0 = TREE_OPERAND (con0, 0); 284390075Sobrien } 284490075Sobrien else 284590075Sobrien lit0 = integer_zero_node; 284690075Sobrien 284790075Sobrien if (TREE_CODE (con1) == PLUS_EXPR) 284890075Sobrien { 284990075Sobrien lit1 = TREE_OPERAND (con1, 1); 285090075Sobrien con1 = TREE_OPERAND (con1, 0); 285190075Sobrien } 285290075Sobrien else 285390075Sobrien lit1 = integer_zero_node; 285490075Sobrien 285590075Sobrien if (operand_equal_p (con0, con1, 0)) 285690075Sobrien { 285790075Sobrien op0 = lit0; 285890075Sobrien op1 = lit1; 285990075Sobrien } 286090075Sobrien 286190075Sobrien 286218334Speter /* First do the subtraction as integers; 286350397Sobrien then drop through to build the divide operator. 286450397Sobrien Do not do default conversions on the minus operator 286550397Sobrien in case restype is a short type. */ 286618334Speter 286718334Speter op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 286850397Sobrien convert (restype, op1), 0); 286918334Speter /* This generates an error if op1 is pointer to incomplete type. */ 287090075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 287118334Speter error ("arithmetic on pointer to an incomplete type"); 287218334Speter 287318334Speter /* This generates an error if op0 is pointer to incomplete type. */ 287418334Speter op1 = c_size_in_bytes (target_type); 287518334Speter 287618334Speter /* Divide by the size, in easiest possible way. */ 2877169689Skan return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 287818334Speter} 287918334Speter 288018334Speter/* Construct and perhaps optimize a tree representation 288118334Speter for a unary operation. CODE, a tree_code, specifies the operation 288290075Sobrien and XARG is the operand. 288390075Sobrien For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 288490075Sobrien the default promotions (such as from short to int). 288590075Sobrien For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 288690075Sobrien allows non-lvalues; this is only used to handle conversion of non-lvalue 288790075Sobrien arrays to pointers in C99. */ 288818334Speter 288918334Spetertree 2890132718Skanbuild_unary_op (enum tree_code code, tree xarg, int flag) 289118334Speter{ 289218334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 289390075Sobrien tree arg = xarg; 289490075Sobrien tree argtype = 0; 289590075Sobrien enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 289618334Speter tree val; 289790075Sobrien int noconvert = flag; 2898169689Skan const char *invalid_op_diag; 289918334Speter 290018334Speter if (typecode == ERROR_MARK) 290118334Speter return error_mark_node; 290290075Sobrien if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 290318334Speter typecode = INTEGER_TYPE; 290418334Speter 2905169689Skan if ((invalid_op_diag 2906169689Skan = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2907169689Skan { 2908259666Spfg error (invalid_op_diag, ""); 2909169689Skan return error_mark_node; 2910169689Skan } 2911169689Skan 291218334Speter switch (code) 291318334Speter { 291418334Speter case CONVERT_EXPR: 291518334Speter /* This is used for unary plus, because a CONVERT_EXPR 291618334Speter is enough to prevent anybody from looking inside for 291718334Speter associativity, but won't generate any code. */ 291818334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2919169689Skan || typecode == COMPLEX_TYPE 2920169689Skan || typecode == VECTOR_TYPE)) 292152284Sobrien { 292252284Sobrien error ("wrong type argument to unary plus"); 292352284Sobrien return error_mark_node; 292452284Sobrien } 292518334Speter else if (!noconvert) 292618334Speter arg = default_conversion (arg); 2927117395Skan arg = non_lvalue (arg); 292818334Speter break; 292918334Speter 293018334Speter case NEGATE_EXPR: 293118334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2932117395Skan || typecode == COMPLEX_TYPE 2933117395Skan || typecode == VECTOR_TYPE)) 293452284Sobrien { 293552284Sobrien error ("wrong type argument to unary minus"); 293652284Sobrien return error_mark_node; 293752284Sobrien } 293818334Speter else if (!noconvert) 293918334Speter arg = default_conversion (arg); 294018334Speter break; 294118334Speter 294218334Speter case BIT_NOT_EXPR: 2943117395Skan if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 294418334Speter { 2945117395Skan if (!noconvert) 2946117395Skan arg = default_conversion (arg); 2947117395Skan } 2948117395Skan else if (typecode == COMPLEX_TYPE) 2949117395Skan { 295018334Speter code = CONJ_EXPR; 295190075Sobrien if (pedantic) 2952169689Skan pedwarn ("ISO C does not support %<~%> for complex conjugation"); 295318334Speter if (!noconvert) 295418334Speter arg = default_conversion (arg); 295518334Speter } 2956117395Skan else 295752284Sobrien { 295852284Sobrien error ("wrong type argument to bit-complement"); 295952284Sobrien return error_mark_node; 296052284Sobrien } 296118334Speter break; 296218334Speter 296318334Speter case ABS_EXPR: 2964132718Skan if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 296552284Sobrien { 296652284Sobrien error ("wrong type argument to abs"); 296752284Sobrien return error_mark_node; 296852284Sobrien } 296918334Speter else if (!noconvert) 297018334Speter arg = default_conversion (arg); 297118334Speter break; 297218334Speter 297318334Speter case CONJ_EXPR: 297418334Speter /* Conjugating a real value is a no-op, but allow it anyway. */ 297518334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 297618334Speter || typecode == COMPLEX_TYPE)) 297752284Sobrien { 297852284Sobrien error ("wrong type argument to conjugation"); 297952284Sobrien return error_mark_node; 298052284Sobrien } 298118334Speter else if (!noconvert) 298218334Speter arg = default_conversion (arg); 298318334Speter break; 298418334Speter 298518334Speter case TRUTH_NOT_EXPR: 298618334Speter if (typecode != INTEGER_TYPE 2987260311Spfg /* APPLE LOCAL radar 5732232 - blocks */ 2988260311Spfg && typecode != BLOCK_POINTER_TYPE 298918334Speter && typecode != REAL_TYPE && typecode != POINTER_TYPE 2990169689Skan && typecode != COMPLEX_TYPE) 299118334Speter { 299252284Sobrien error ("wrong type argument to unary exclamation mark"); 299352284Sobrien return error_mark_node; 299418334Speter } 2995169689Skan arg = c_objc_common_truthvalue_conversion (arg); 299618334Speter return invert_truthvalue (arg); 299718334Speter 299818334Speter case REALPART_EXPR: 299918334Speter if (TREE_CODE (arg) == COMPLEX_CST) 300018334Speter return TREE_REALPART (arg); 300118334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 3002169689Skan return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 300318334Speter else 300418334Speter return arg; 300518334Speter 300618334Speter case IMAGPART_EXPR: 300718334Speter if (TREE_CODE (arg) == COMPLEX_CST) 300818334Speter return TREE_IMAGPART (arg); 300918334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 3010169689Skan return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 301118334Speter else 301218334Speter return convert (TREE_TYPE (arg), integer_zero_node); 3013132718Skan 301418334Speter case PREINCREMENT_EXPR: 301518334Speter case POSTINCREMENT_EXPR: 301618334Speter case PREDECREMENT_EXPR: 301718334Speter case POSTDECREMENT_EXPR: 301818334Speter 301918334Speter /* Increment or decrement the real part of the value, 302018334Speter and don't change the imaginary part. */ 302118334Speter if (typecode == COMPLEX_TYPE) 302218334Speter { 302318334Speter tree real, imag; 302418334Speter 302590075Sobrien if (pedantic) 3026169689Skan pedwarn ("ISO C does not support %<++%> and %<--%>" 3027169689Skan " on complex types"); 302890075Sobrien 302918334Speter arg = stabilize_reference (arg); 303018334Speter real = build_unary_op (REALPART_EXPR, arg, 1); 303118334Speter imag = build_unary_op (IMAGPART_EXPR, arg, 1); 3032169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 3033169689Skan build_unary_op (code, real, 1), imag); 303418334Speter } 303518334Speter 303618334Speter /* Report invalid types. */ 303718334Speter 303818334Speter if (typecode != POINTER_TYPE 303918334Speter && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 304018334Speter { 304190075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 3042169689Skan error ("wrong type argument to increment"); 3043169689Skan else 3044169689Skan error ("wrong type argument to decrement"); 304590075Sobrien 304652284Sobrien return error_mark_node; 304718334Speter } 304818334Speter 304918334Speter { 305090075Sobrien tree inc; 305118334Speter tree result_type = TREE_TYPE (arg); 305218334Speter 3053117395Skan arg = get_unwidened (arg, 0); 3054117395Skan argtype = TREE_TYPE (arg); 3055117395Skan 305618334Speter /* Compute the increment. */ 305718334Speter 305818334Speter if (typecode == POINTER_TYPE) 305918334Speter { 306018334Speter /* If pointer target is an undefined struct, 306118334Speter we just cannot know how to do the arithmetic. */ 306290075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 306390075Sobrien { 306490075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 306590075Sobrien error ("increment of pointer to unknown structure"); 306690075Sobrien else 306790075Sobrien error ("decrement of pointer to unknown structure"); 306890075Sobrien } 306918334Speter else if ((pedantic || warn_pointer_arith) 307018334Speter && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 307118334Speter || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 3072169689Skan { 307390075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 307490075Sobrien pedwarn ("wrong type argument to increment"); 307590075Sobrien else 307690075Sobrien pedwarn ("wrong type argument to decrement"); 307790075Sobrien } 307890075Sobrien 307918334Speter inc = c_size_in_bytes (TREE_TYPE (result_type)); 308018334Speter } 308118334Speter else 308218334Speter inc = integer_one_node; 308318334Speter 308418334Speter inc = convert (argtype, inc); 308518334Speter 308618334Speter /* Complain about anything else that is not a true lvalue. */ 308718334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 308818334Speter || code == POSTINCREMENT_EXPR) 3089169689Skan ? lv_increment 3090169689Skan : lv_decrement))) 309118334Speter return error_mark_node; 309218334Speter 309318334Speter /* Report a read-only lvalue. */ 309418334Speter if (TREE_READONLY (arg)) 3095169689Skan { 3096169689Skan readonly_error (arg, 3097169689Skan ((code == PREINCREMENT_EXPR 3098169689Skan || code == POSTINCREMENT_EXPR) 3099169689Skan ? lv_increment : lv_decrement)); 3100169689Skan return error_mark_node; 3101169689Skan } 310218334Speter 310390075Sobrien if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 310490075Sobrien val = boolean_increment (code, arg); 310590075Sobrien else 3106169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 310718334Speter TREE_SIDE_EFFECTS (val) = 1; 310818334Speter val = convert (result_type, val); 310918334Speter if (TREE_CODE (val) != code) 3110169689Skan TREE_NO_WARNING (val) = 1; 311118334Speter return val; 311218334Speter } 311318334Speter 311418334Speter case ADDR_EXPR: 311590075Sobrien /* Note that this operation never does default_conversion. */ 311618334Speter 311718334Speter /* Let &* cancel out to simplify resulting code. */ 311818334Speter if (TREE_CODE (arg) == INDIRECT_REF) 311918334Speter { 312018334Speter /* Don't let this be an lvalue. */ 312118334Speter if (lvalue_p (TREE_OPERAND (arg, 0))) 312218334Speter return non_lvalue (TREE_OPERAND (arg, 0)); 312318334Speter return TREE_OPERAND (arg, 0); 312418334Speter } 312518334Speter 312618334Speter /* For &x[y], return x+y */ 312718334Speter if (TREE_CODE (arg) == ARRAY_REF) 312818334Speter { 3129169689Skan tree op0 = TREE_OPERAND (arg, 0); 3130169689Skan if (!c_mark_addressable (op0)) 313118334Speter return error_mark_node; 3132169689Skan return build_binary_op (PLUS_EXPR, 3133169689Skan (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3134169689Skan ? array_to_pointer_conversion (op0) 3135169689Skan : op0), 313618334Speter TREE_OPERAND (arg, 1), 1); 313718334Speter } 313818334Speter 313918334Speter /* Anything not already handled and not a true memory reference 314090075Sobrien or a non-lvalue array is an error. */ 314190075Sobrien else if (typecode != FUNCTION_TYPE && !flag 3142169689Skan && !lvalue_or_else (arg, lv_addressof)) 314318334Speter return error_mark_node; 314418334Speter 314518334Speter /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 314618334Speter argtype = TREE_TYPE (arg); 314790075Sobrien 314852284Sobrien /* If the lvalue is const or volatile, merge that into the type 3149169689Skan to which the address will point. Note that you can't get a 315052284Sobrien restricted pointer by taking the address of something, so we 315152284Sobrien only have to deal with `const' and `volatile' here. */ 3152169689Skan if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 315390075Sobrien && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 315490075Sobrien argtype = c_build_type_variant (argtype, 315590075Sobrien TREE_READONLY (arg), 315690075Sobrien TREE_THIS_VOLATILE (arg)); 315718334Speter 3158117395Skan if (!c_mark_addressable (arg)) 315918334Speter return error_mark_node; 316018334Speter 3161169689Skan gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3162169689Skan || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 316318334Speter 3164169689Skan argtype = build_pointer_type (argtype); 316518334Speter 3166169689Skan /* ??? Cope with user tricks that amount to offsetof. Delete this 3167169689Skan when we have proper support for integer constant expressions. */ 3168169689Skan val = get_base_address (arg); 3169169689Skan if (val && TREE_CODE (val) == INDIRECT_REF 3170169689Skan && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3171169689Skan { 3172169689Skan tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 317318334Speter 3174169689Skan op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3175169689Skan return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3176169689Skan } 317718334Speter 3178169689Skan val = build1 (ADDR_EXPR, argtype, arg); 317918334Speter 3180169689Skan return val; 318150397Sobrien 318250397Sobrien default: 3183169689Skan gcc_unreachable (); 318418334Speter } 318518334Speter 318652284Sobrien if (argtype == 0) 318752284Sobrien argtype = TREE_TYPE (arg); 3188169689Skan return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3189169689Skan : fold_build1 (code, argtype, arg); 319018334Speter} 319118334Speter 319218334Speter/* Return nonzero if REF is an lvalue valid for this language. 319318334Speter Lvalues can be assigned, unless their type has TYPE_READONLY. 3194169689Skan Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 319518334Speter 3196169689Skanstatic int 3197132718Skanlvalue_p (tree ref) 319818334Speter{ 319990075Sobrien enum tree_code code = TREE_CODE (ref); 320018334Speter 320118334Speter switch (code) 320218334Speter { 320318334Speter case REALPART_EXPR: 320418334Speter case IMAGPART_EXPR: 320518334Speter case COMPONENT_REF: 320618334Speter return lvalue_p (TREE_OPERAND (ref, 0)); 320718334Speter 320890075Sobrien case COMPOUND_LITERAL_EXPR: 320918334Speter case STRING_CST: 321018334Speter return 1; 321118334Speter 321218334Speter case INDIRECT_REF: 321318334Speter case ARRAY_REF: 321418334Speter case VAR_DECL: 321518334Speter case PARM_DECL: 321618334Speter case RESULT_DECL: 321718334Speter case ERROR_MARK: 321850397Sobrien return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 321950397Sobrien && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 322050397Sobrien 322150397Sobrien case BIND_EXPR: 322250397Sobrien return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 322350397Sobrien 322450397Sobrien default: 322550397Sobrien return 0; 322618334Speter } 322718334Speter} 3228169689Skan 3229169689Skan/* Give an error for storing in something that is 'const'. */ 323018334Speter 323118334Speterstatic void 3232169689Skanreadonly_error (tree arg, enum lvalue_use use) 323318334Speter{ 3234169689Skan gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3235169689Skan || use == lv_asm); 3236169689Skan /* Using this macro rather than (for example) arrays of messages 3237169689Skan ensures that all the format strings are checked at compile 3238169689Skan time. */ 3239169689Skan#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3240169689Skan : (use == lv_increment ? (I) \ 3241169689Skan : (use == lv_decrement ? (D) : (AS)))) 324218334Speter if (TREE_CODE (arg) == COMPONENT_REF) 324318334Speter { 324418334Speter if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3245169689Skan readonly_error (TREE_OPERAND (arg, 0), use); 324618334Speter else 3247169689Skan error (READONLY_MSG (G_("assignment of read-only member %qD"), 3248169689Skan G_("increment of read-only member %qD"), 3249169689Skan G_("decrement of read-only member %qD"), 3250169689Skan G_("read-only member %qD used as %<asm%> output")), 3251169689Skan TREE_OPERAND (arg, 1)); 325218334Speter } 325318334Speter else if (TREE_CODE (arg) == VAR_DECL) 3254169689Skan error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3255169689Skan G_("increment of read-only variable %qD"), 3256169689Skan G_("decrement of read-only variable %qD"), 3257169689Skan G_("read-only variable %qD used as %<asm%> output")), 3258169689Skan arg); 325918334Speter else 3260169689Skan error (READONLY_MSG (G_("assignment of read-only location"), 3261169689Skan G_("increment of read-only location"), 3262169689Skan G_("decrement of read-only location"), 3263169689Skan G_("read-only location used as %<asm%> output"))); 326418334Speter} 3265169689Skan 3266169689Skan 3267169689Skan/* Return nonzero if REF is an lvalue valid for this language; 3268169689Skan otherwise, print an error message and return zero. USE says 3269169689Skan how the lvalue is being used and so selects the error message. */ 3270169689Skan 3271169689Skanstatic int 3272169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 3273169689Skan{ 3274169689Skan int win = lvalue_p (ref); 3275169689Skan 3276169689Skan if (!win) 3277169689Skan lvalue_error (use); 3278169689Skan 3279169689Skan return win; 3280169689Skan} 328118334Speter 328218334Speter/* Mark EXP saying that we need to be able to take the 328318334Speter address of it; it should not be allocated in a register. 3284117395Skan Returns true if successful. */ 328518334Speter 3286117395Skanbool 3287132718Skanc_mark_addressable (tree exp) 328818334Speter{ 328990075Sobrien tree x = exp; 3290117395Skan 329118334Speter while (1) 329218334Speter switch (TREE_CODE (x)) 329318334Speter { 329450397Sobrien case COMPONENT_REF: 329550397Sobrien if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 329650397Sobrien { 3297169689Skan error 3298169689Skan ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3299117395Skan return false; 330050397Sobrien } 330150397Sobrien 330250397Sobrien /* ... fall through ... */ 330350397Sobrien 330418334Speter case ADDR_EXPR: 330518334Speter case ARRAY_REF: 330618334Speter case REALPART_EXPR: 330718334Speter case IMAGPART_EXPR: 330818334Speter x = TREE_OPERAND (x, 0); 330918334Speter break; 331018334Speter 331190075Sobrien case COMPOUND_LITERAL_EXPR: 331218334Speter case CONSTRUCTOR: 331318334Speter TREE_ADDRESSABLE (x) = 1; 3314117395Skan return true; 331518334Speter 331618334Speter case VAR_DECL: 331718334Speter case CONST_DECL: 331818334Speter case PARM_DECL: 331918334Speter case RESULT_DECL: 3320169689Skan if (C_DECL_REGISTER (x) 332118334Speter && DECL_NONLOCAL (x)) 332218334Speter { 3323132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 332418334Speter { 3325169689Skan error 3326169689Skan ("global register variable %qD used in nested function", x); 3327117395Skan return false; 332818334Speter } 3329169689Skan pedwarn ("register variable %qD used in nested function", x); 333018334Speter } 3331169689Skan else if (C_DECL_REGISTER (x)) 333218334Speter { 3333132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3334169689Skan error ("address of global register variable %qD requested", x); 3335169689Skan else 3336169689Skan error ("address of register variable %qD requested", x); 3337169689Skan return false; 333818334Speter } 333918334Speter 334018334Speter /* drops in */ 334118334Speter case FUNCTION_DECL: 334218334Speter TREE_ADDRESSABLE (x) = 1; 3343132718Skan /* drops out */ 334418334Speter default: 3345117395Skan return true; 334618334Speter } 334718334Speter} 334818334Speter 334918334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 335018334Speter 335118334Spetertree 3352132718Skanbuild_conditional_expr (tree ifexp, tree op1, tree op2) 335318334Speter{ 335490075Sobrien tree type1; 335590075Sobrien tree type2; 335690075Sobrien enum tree_code code1; 335790075Sobrien enum tree_code code2; 335890075Sobrien tree result_type = NULL; 335918334Speter tree orig_op1 = op1, orig_op2 = op2; 336018334Speter 336118334Speter /* Promote both alternatives. */ 336218334Speter 336318334Speter if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 336418334Speter op1 = default_conversion (op1); 336518334Speter if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 336618334Speter op2 = default_conversion (op2); 336718334Speter 336818334Speter if (TREE_CODE (ifexp) == ERROR_MARK 336918334Speter || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 337018334Speter || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 337118334Speter return error_mark_node; 337218334Speter 337318334Speter type1 = TREE_TYPE (op1); 337418334Speter code1 = TREE_CODE (type1); 337518334Speter type2 = TREE_TYPE (op2); 337618334Speter code2 = TREE_CODE (type2); 3377132718Skan 3378169689Skan /* C90 does not permit non-lvalue arrays in conditional expressions. 3379169689Skan In C99 they will be pointers by now. */ 3380169689Skan if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3381169689Skan { 3382169689Skan error ("non-lvalue array in conditional expression"); 3383169689Skan return error_mark_node; 3384169689Skan } 3385169689Skan 338618334Speter /* Quickly detect the usual case where op1 and op2 have the same type 338718334Speter after promotion. */ 338818334Speter if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 338918334Speter { 339018334Speter if (type1 == type2) 339118334Speter result_type = type1; 339218334Speter else 339318334Speter result_type = TYPE_MAIN_VARIANT (type1); 339418334Speter } 339590075Sobrien else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3396169689Skan || code1 == COMPLEX_TYPE) 3397169689Skan && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3398169689Skan || code2 == COMPLEX_TYPE)) 339918334Speter { 3400169689Skan result_type = c_common_type (type1, type2); 340190075Sobrien 340290075Sobrien /* If -Wsign-compare, warn here if type1 and type2 have 340390075Sobrien different signedness. We'll promote the signed to unsigned 340490075Sobrien and later code won't know it used to be different. 340590075Sobrien Do this check on the original types, so that explicit casts 340690075Sobrien will be considered, but default promotions won't. */ 3407132718Skan if (warn_sign_compare && !skip_evaluation) 340890075Sobrien { 3409169689Skan int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3410169689Skan int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 341190075Sobrien 341290075Sobrien if (unsigned_op1 ^ unsigned_op2) 341390075Sobrien { 3414169689Skan bool ovf; 3415169689Skan 341690075Sobrien /* Do not warn if the result type is signed, since the 341790075Sobrien signed type will only be chosen if it can represent 341890075Sobrien all the values of the unsigned type. */ 3419169689Skan if (!TYPE_UNSIGNED (result_type)) 342090075Sobrien /* OK */; 342190075Sobrien /* Do not warn if the signed quantity is an unsuffixed 342290075Sobrien integer literal (or some static constant expression 342390075Sobrien involving such literals) and it is non-negative. */ 3424169689Skan else if ((unsigned_op2 3425169689Skan && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3426169689Skan || (unsigned_op1 3427169689Skan && tree_expr_nonnegative_warnv_p (op2, &ovf))) 342890075Sobrien /* OK */; 342990075Sobrien else 3430169689Skan warning (0, "signed and unsigned type in conditional expression"); 343190075Sobrien } 343290075Sobrien } 343318334Speter } 343418334Speter else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 343518334Speter { 343618334Speter if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 343790075Sobrien pedwarn ("ISO C forbids conditional expr with only one void side"); 343818334Speter result_type = void_type_node; 343918334Speter } 3440260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 3441260311Spfg else if ((code1 == POINTER_TYPE 3442260311Spfg || code1 == BLOCK_POINTER_TYPE) 3443260311Spfg && (code2 == POINTER_TYPE 3444260311Spfg || code2 == BLOCK_POINTER_TYPE)) 3445260311Spfg /* APPLE LOCAL end blocks 6065211 */ 344618334Speter { 3447169689Skan if (comp_target_types (type1, type2)) 3448169689Skan result_type = common_pointer_type (type1, type2); 3449169689Skan else if (null_pointer_constant_p (orig_op1)) 345018334Speter result_type = qualify_type (type2, type1); 3451169689Skan else if (null_pointer_constant_p (orig_op2)) 345218334Speter result_type = qualify_type (type1, type2); 3453260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 3454260311Spfg else if (code2 == BLOCK_POINTER_TYPE 3455260311Spfg && VOID_TYPE_P (TREE_TYPE (type1))) 3456260311Spfg result_type = type2; 3457260311Spfg else if (code1 == BLOCK_POINTER_TYPE 3458260311Spfg && VOID_TYPE_P (TREE_TYPE (type2))) 3459260311Spfg result_type = type1; 3460260311Spfg /* APPLE LOCAL end blocks 6065211 */ 346190075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type1))) 346218334Speter { 346318334Speter if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3464169689Skan pedwarn ("ISO C forbids conditional expr between " 3465169689Skan "%<void *%> and function pointer"); 346690075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 346790075Sobrien TREE_TYPE (type2))); 346818334Speter } 346990075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type2))) 347018334Speter { 347118334Speter if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3472169689Skan pedwarn ("ISO C forbids conditional expr between " 3473169689Skan "%<void *%> and function pointer"); 347490075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 347590075Sobrien TREE_TYPE (type1))); 347618334Speter } 347718334Speter else 347818334Speter { 347918334Speter pedwarn ("pointer type mismatch in conditional expression"); 348018334Speter result_type = build_pointer_type (void_type_node); 348118334Speter } 348218334Speter } 348318334Speter else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 348418334Speter { 3485169689Skan if (!null_pointer_constant_p (orig_op2)) 348618334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 348718334Speter else 348818334Speter { 348918334Speter op2 = null_pointer_node; 349018334Speter } 349118334Speter result_type = type1; 349218334Speter } 349318334Speter else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 349418334Speter { 3495169689Skan if (!null_pointer_constant_p (orig_op1)) 349618334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 349718334Speter else 349818334Speter { 349918334Speter op1 = null_pointer_node; 350018334Speter } 350118334Speter result_type = type2; 350218334Speter } 3503260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks (C++ co) */ 3504260311Spfg /* APPLE LOCAL radar 5957801 */ 3505260311Spfg else if (code1 == BLOCK_POINTER_TYPE && code2 == INTEGER_TYPE) 3506260311Spfg { 3507260311Spfg if (!null_pointer_constant_p (orig_op2)) 3508260311Spfg error ("block pointer/integer type mismatch in conditional expression"); 3509260311Spfg else 3510260311Spfg { 3511260311Spfg op2 = convert (type1, null_pointer_node); 3512260311Spfg } 3513260311Spfg result_type = type1; 3514260311Spfg } 3515260311Spfg /* APPLE LOCAL radar 5957801 */ 3516260311Spfg else if (code2 == BLOCK_POINTER_TYPE && code1 == INTEGER_TYPE) 3517260311Spfg { 3518260311Spfg if (!null_pointer_constant_p (orig_op1)) 3519260311Spfg error ("block pointer/integer type mismatch in conditional expression"); 3520260311Spfg else 3521260311Spfg { 3522260311Spfg op1 = convert (type2, null_pointer_node); 3523260311Spfg } 3524260311Spfg result_type = type2; 3525260311Spfg } 3526260311Spfg 3527260311Spfg /* APPLE LOCAL end radar 5732232 - blocks (C++ co) */ 352818334Speter if (!result_type) 352918334Speter { 353018334Speter if (flag_cond_mismatch) 353118334Speter result_type = void_type_node; 353218334Speter else 353318334Speter { 353418334Speter error ("type mismatch in conditional expression"); 353518334Speter return error_mark_node; 353618334Speter } 353718334Speter } 353818334Speter 353918334Speter /* Merge const and volatile flags of the incoming types. */ 354018334Speter result_type 354118334Speter = build_type_variant (result_type, 354218334Speter TREE_READONLY (op1) || TREE_READONLY (op2), 354318334Speter TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 354418334Speter 354518334Speter if (result_type != TREE_TYPE (op1)) 354618334Speter op1 = convert_and_check (result_type, op1); 354718334Speter if (result_type != TREE_TYPE (op2)) 354818334Speter op2 = convert_and_check (result_type, op2); 3549132718Skan 3550169689Skan return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 355118334Speter} 355218334Speter 3553169689Skan/* Return a compound expression that performs two expressions and 3554169689Skan returns the value of the second of them. */ 355518334Speter 355618334Spetertree 3557169689Skanbuild_compound_expr (tree expr1, tree expr2) 355818334Speter{ 3559169689Skan if (!TREE_SIDE_EFFECTS (expr1)) 356018334Speter { 356118334Speter /* The left-hand operand of a comma expression is like an expression 3562169689Skan statement: with -Wextra or -Wunused, we should warn if it doesn't have 356318334Speter any side-effects, unless it was explicitly cast to (void). */ 3564169689Skan if (warn_unused_value) 3565169689Skan { 3566169689Skan if (VOID_TYPE_P (TREE_TYPE (expr1)) 3567169689Skan && (TREE_CODE (expr1) == NOP_EXPR 3568169689Skan || TREE_CODE (expr1) == CONVERT_EXPR)) 3569169689Skan ; /* (void) a, b */ 3570169689Skan else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3571169689Skan && TREE_CODE (expr1) == COMPOUND_EXPR 3572169689Skan && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3573169689Skan || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3574169689Skan ; /* (void) a, (void) b, c */ 3575169689Skan else 3576169689Skan warning (0, "left-hand operand of comma expression has no effect"); 3577169689Skan } 357818334Speter } 357918334Speter 358018334Speter /* With -Wunused, we should also warn if the left-hand operand does have 358118334Speter side-effects, but computes a value which is not used. For example, in 358218334Speter `foo() + bar(), baz()' the result of the `+' operator is not used, 358318334Speter so we should issue a warning. */ 358490075Sobrien else if (warn_unused_value) 3585169689Skan warn_if_unused_value (expr1, input_location); 358618334Speter 3587169689Skan if (expr2 == error_mark_node) 3588169689Skan return error_mark_node; 3589169689Skan 3590169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 359118334Speter} 359218334Speter 359318334Speter/* Build an expression representing a cast to type TYPE of expression EXPR. */ 359418334Speter 359518334Spetertree 3596132718Skanbuild_c_cast (tree type, tree expr) 359718334Speter{ 359890075Sobrien tree value = expr; 3599132718Skan 360018334Speter if (type == error_mark_node || expr == error_mark_node) 360118334Speter return error_mark_node; 360218334Speter 3603117395Skan /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3604117395Skan only in <protocol> qualifications. But when constructing cast expressions, 3605117395Skan the protocols do matter and must be kept around. */ 3606169689Skan if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3607169689Skan return build1 (NOP_EXPR, type, expr); 3608117395Skan 3609169689Skan type = TYPE_MAIN_VARIANT (type); 3610169689Skan 361118334Speter if (TREE_CODE (type) == ARRAY_TYPE) 361218334Speter { 361318334Speter error ("cast specifies array type"); 361418334Speter return error_mark_node; 361518334Speter } 361618334Speter 361718334Speter if (TREE_CODE (type) == FUNCTION_TYPE) 361818334Speter { 361918334Speter error ("cast specifies function type"); 362018334Speter return error_mark_node; 362118334Speter } 362218334Speter 362390075Sobrien if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 362418334Speter { 362518334Speter if (pedantic) 362618334Speter { 362718334Speter if (TREE_CODE (type) == RECORD_TYPE 362818334Speter || TREE_CODE (type) == UNION_TYPE) 362990075Sobrien pedwarn ("ISO C forbids casting nonscalar to the same type"); 363018334Speter } 363118334Speter } 363218334Speter else if (TREE_CODE (type) == UNION_TYPE) 363318334Speter { 363418334Speter tree field; 363518334Speter 363618334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 363718334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3638169689Skan TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 363918334Speter break; 364018334Speter 364118334Speter if (field) 364218334Speter { 364318334Speter tree t; 364418334Speter 364518334Speter if (pedantic) 364690075Sobrien pedwarn ("ISO C forbids casts to union type"); 3647132718Skan t = digest_init (type, 3648169689Skan build_constructor_single (type, field, value), 3649169689Skan true, 0); 365018334Speter TREE_CONSTANT (t) = TREE_CONSTANT (value); 3651169689Skan TREE_INVARIANT (t) = TREE_INVARIANT (value); 365218334Speter return t; 365318334Speter } 365418334Speter error ("cast to union type from type not present in union"); 365518334Speter return error_mark_node; 365618334Speter } 365718334Speter else 365818334Speter { 365918334Speter tree otype, ovalue; 366018334Speter 366118334Speter if (type == void_type_node) 366218334Speter return build1 (CONVERT_EXPR, type, value); 366318334Speter 366418334Speter otype = TREE_TYPE (value); 366518334Speter 3666260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 3667260311Spfg if (TREE_CODE (otype) == BLOCK_POINTER_TYPE && 3668260311Spfg TREE_CODE (type) == POINTER_TYPE && VOID_TYPE_P (TREE_TYPE (type))) 3669260311Spfg return build1 (NOP_EXPR, type, value); 3670260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 3671260311Spfg 367218334Speter /* Optionally warn about potentially worrisome casts. */ 367318334Speter 367418334Speter if (warn_cast_qual 367518334Speter && TREE_CODE (type) == POINTER_TYPE 367618334Speter && TREE_CODE (otype) == POINTER_TYPE) 367718334Speter { 367850397Sobrien tree in_type = type; 367950397Sobrien tree in_otype = otype; 368096263Sobrien int added = 0; 368196263Sobrien int discarded = 0; 368250397Sobrien 368390075Sobrien /* Check that the qualifiers on IN_TYPE are a superset of 368490075Sobrien the qualifiers of IN_OTYPE. The outermost level of 368590075Sobrien POINTER_TYPE nodes is uninteresting and we stop as soon 368690075Sobrien as we hit a non-POINTER_TYPE node on either type. */ 368790075Sobrien do 368890075Sobrien { 368990075Sobrien in_otype = TREE_TYPE (in_otype); 369090075Sobrien in_type = TREE_TYPE (in_type); 369196263Sobrien 369296263Sobrien /* GNU C allows cv-qualified function types. 'const' 369396263Sobrien means the function is very pure, 'volatile' means it 369496263Sobrien can't return. We need to warn when such qualifiers 369596263Sobrien are added, not when they're taken away. */ 369696263Sobrien if (TREE_CODE (in_otype) == FUNCTION_TYPE 369796263Sobrien && TREE_CODE (in_type) == FUNCTION_TYPE) 369896263Sobrien added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 369996263Sobrien else 370096263Sobrien discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 370190075Sobrien } 370290075Sobrien while (TREE_CODE (in_type) == POINTER_TYPE 370390075Sobrien && TREE_CODE (in_otype) == POINTER_TYPE); 370490075Sobrien 370596263Sobrien if (added) 3706169689Skan warning (0, "cast adds new qualifiers to function type"); 370796263Sobrien 370896263Sobrien if (discarded) 370952284Sobrien /* There are qualifiers present in IN_OTYPE that are not 371052284Sobrien present in IN_TYPE. */ 3711169689Skan warning (0, "cast discards qualifiers from pointer target type"); 371218334Speter } 371318334Speter 371418334Speter /* Warn about possible alignment problems. */ 3715169689Skan if (STRICT_ALIGNMENT 371618334Speter && TREE_CODE (type) == POINTER_TYPE 371718334Speter && TREE_CODE (otype) == POINTER_TYPE 371818334Speter && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 371918334Speter && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 372050397Sobrien /* Don't warn about opaque types, where the actual alignment 372150397Sobrien restriction is unknown. */ 372250397Sobrien && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 372350397Sobrien || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 372450397Sobrien && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 372518334Speter && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3726169689Skan warning (OPT_Wcast_align, 3727169689Skan "cast increases required alignment of target type"); 372818334Speter 372918334Speter if (TREE_CODE (type) == INTEGER_TYPE 373018334Speter && TREE_CODE (otype) == POINTER_TYPE 3731169689Skan && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3732169689Skan /* Unlike conversion of integers to pointers, where the 3733169689Skan warning is disabled for converting constants because 3734169689Skan of cases such as SIG_*, warn about converting constant 3735169689Skan pointers to integers. In some cases it may cause unwanted 3736169689Skan sign extension, and a warning is appropriate. */ 3737169689Skan warning (OPT_Wpointer_to_int_cast, 3738169689Skan "cast from pointer to integer of different size"); 373918334Speter 3740169689Skan if (TREE_CODE (value) == CALL_EXPR 374118334Speter && TREE_CODE (type) != TREE_CODE (otype)) 3742169689Skan warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3743169689Skan "to non-matching type %qT", otype, type); 374418334Speter 374518334Speter if (TREE_CODE (type) == POINTER_TYPE 374618334Speter && TREE_CODE (otype) == INTEGER_TYPE 374718334Speter && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 374818334Speter /* Don't warn about converting any constant. */ 374918334Speter && !TREE_CONSTANT (value)) 3750169689Skan warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3751169689Skan "of different size"); 375218334Speter 3753258501Spfg if (warn_strict_aliasing <= 2) 3754258501Spfg strict_aliasing_warning (otype, type, expr); 3755132718Skan 3756132718Skan /* If pedantic, warn for conversions between function and object 3757132718Skan pointer types, except for converting a null pointer constant 3758132718Skan to function pointer type. */ 3759132718Skan if (pedantic 3760132718Skan && TREE_CODE (type) == POINTER_TYPE 3761132718Skan && TREE_CODE (otype) == POINTER_TYPE 3762132718Skan && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3763132718Skan && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3764132718Skan pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3765132718Skan 3766132718Skan if (pedantic 3767132718Skan && TREE_CODE (type) == POINTER_TYPE 3768132718Skan && TREE_CODE (otype) == POINTER_TYPE 3769132718Skan && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3770132718Skan && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3771169689Skan && !null_pointer_constant_p (value)) 3772132718Skan pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3773132718Skan 377418334Speter ovalue = value; 3775260311Spfg /* APPLE LOCAL begin don't sign-extend pointers cast to integers */ 3776260311Spfg if (TREE_CODE (type) == INTEGER_TYPE 3777260311Spfg && TREE_CODE (otype) == POINTER_TYPE 3778260311Spfg && TYPE_PRECISION (type) > TYPE_PRECISION (otype) 3779260311Spfg && TYPE_UNSIGNED (type)) 3780260311Spfg value = convert (c_common_type_for_size (POINTER_SIZE, 1), value); 3781260311Spfg /* APPLE LOCAL end don't sign-extend pointers cast to integers */ 378218334Speter value = convert (type, value); 378318334Speter 378418334Speter /* Ignore any integer overflow caused by the cast. */ 378518334Speter if (TREE_CODE (value) == INTEGER_CST) 378618334Speter { 3787169689Skan if (CONSTANT_CLASS_P (ovalue) 3788169689Skan && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3789169689Skan { 3790169689Skan /* Avoid clobbering a shared constant. */ 3791169689Skan value = copy_node (value); 3792169689Skan TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3793169689Skan TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3794169689Skan } 3795169689Skan else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3796169689Skan /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3797169689Skan value = build_int_cst_wide (TREE_TYPE (value), 3798169689Skan TREE_INT_CST_LOW (value), 3799169689Skan TREE_INT_CST_HIGH (value)); 380018334Speter } 380118334Speter } 380218334Speter 3803169689Skan /* Don't let a cast be an lvalue. */ 3804169689Skan if (value == expr) 380518334Speter value = non_lvalue (value); 380618334Speter 380718334Speter return value; 380818334Speter} 380990075Sobrien 3810260311Spfg/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 3811260311Spfgstatic bool 3812260311Spfgfunctiontypes_are_block_compatible (tree f1, tree f2) 3813260311Spfg{ 3814260311Spfg tree arg1, arg2; 3815260311Spfg if (!types_are_block_compatible (TREE_TYPE (f1), TREE_TYPE (f2))) 3816260311Spfg return false; 3817260311Spfg arg1 = TYPE_ARG_TYPES (f1); 3818260311Spfg arg2 = TYPE_ARG_TYPES (f2); 3819260311Spfg /* APPLE LOCAL radar 6246965, 6196572 */ 3820260311Spfg return (!arg1) || (type_lists_compatible_p (arg1, arg2) == 1); 3821260311Spfg} 3822260311Spfg 3823260311Spfgstatic bool 3824260311Spfgtypes_are_block_compatible (tree lhptee, tree rhptee) 3825260311Spfg{ 3826260311Spfg if (TYPE_MAIN_VARIANT (lhptee) == TYPE_MAIN_VARIANT (rhptee)) 3827260311Spfg return true; 3828260311Spfg if (TREE_CODE (lhptee) == FUNCTION_TYPE && TREE_CODE (rhptee) == FUNCTION_TYPE) 3829260311Spfg return functiontypes_are_block_compatible (lhptee, rhptee); 3830260311Spfg /* APPLE LOCAL begin radar 5882266 (C++ cm) */ 3831260311Spfg if (TREE_CODE (lhptee) == POINTER_TYPE && TREE_CODE (rhptee) == POINTER_TYPE) 3832260311Spfg return types_are_block_compatible (TREE_TYPE (lhptee), TREE_TYPE (rhptee)); 3833260311Spfg /* APPLE LOCAL end radar 5882266 (C++ cm) */ 3834260311Spfg /* APPLE LOCAL begin radar 5988995 (C++ cm) */ 3835260311Spfg if (TREE_CODE (lhptee) == BLOCK_POINTER_TYPE 3836260311Spfg && TREE_CODE (rhptee) == BLOCK_POINTER_TYPE) 3837260311Spfg return types_are_block_compatible (TREE_TYPE (lhptee), TREE_TYPE (rhptee)); 3838260311Spfg /* APPLE LOCAL end radar 5988995 (C++ cm) */ 3839260311Spfg return false; 3840260311Spfg} 3841260311Spfg 3842260311Spfg/* APPLE LOCAL begin radar 5847213 - radar 6329245 */ 3843260311Spfg/** 3844260311Spfg build_block_call - Routine to build a block call; as in: 3845260311Spfg ((double(*)(void *, int))(BLOCK_PTR_EXP->__FuncPtr))(I, 42); 3846260311Spfg FNTYPE is the original function type derived from the syntax. 3847260311Spfg BLOCK_PTR_EXP is the block pointer variable. 3848260311Spfg PARAMS is the parameter list. 3849260311Spfg*/ 3850260311Spfgstatic tree 3851260311Spfgbuild_block_call (tree fntype, tree block_ptr_exp, tree params) 3852260311Spfg{ 3853260311Spfg tree function_ptr_exp; 3854260311Spfg tree typelist; 3855260311Spfg bool block_ptr_exp_side_effect = TREE_SIDE_EFFECTS (block_ptr_exp); 3856260311Spfg 3857260311Spfg /* First convert BLOCK_PTR_EXP to 'void *'. */ 3858260311Spfg block_ptr_exp = convert (ptr_type_node, block_ptr_exp); 3859260311Spfg gcc_assert (generic_block_literal_struct_type); 3860260311Spfg block_ptr_exp = convert (build_pointer_type (generic_block_literal_struct_type), 3861260311Spfg block_ptr_exp); 3862260311Spfg if (block_ptr_exp_side_effect) 3863260311Spfg block_ptr_exp = save_expr (block_ptr_exp); 3864260311Spfg 3865260311Spfg /* BLOCK_PTR_VAR->__FuncPtr */ 3866260311Spfg function_ptr_exp = build_component_ref (build_indirect_ref (block_ptr_exp, "->"), 3867260311Spfg get_identifier ("__FuncPtr")); 3868260311Spfg gcc_assert (function_ptr_exp); 3869260311Spfg 3870260311Spfg /* Build: result_type(*)(void *, function-arg-type-list) */ 3871260311Spfg typelist = TYPE_ARG_TYPES (fntype); 3872260311Spfg typelist = tree_cons (NULL_TREE, ptr_type_node, typelist); 3873260311Spfg fntype = build_function_type (TREE_TYPE (fntype), typelist); 3874260311Spfg function_ptr_exp = convert (build_pointer_type (fntype), function_ptr_exp); 3875260311Spfg params = tree_cons (NULL_TREE, block_ptr_exp, params); 3876260311Spfg return fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 3877260311Spfg function_ptr_exp, params, NULL_TREE); 3878260311Spfg} 3879260311Spfg/* APPLE LOCAL end radar 5847213 - radar 6329245 */ 3880260311Spfg/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 3881260311Spfg 388290075Sobrien/* Interpret a cast of expression EXPR to type TYPE. */ 388390075Sobrientree 3884169689Skanc_cast_expr (struct c_type_name *type_name, tree expr) 388590075Sobrien{ 3886169689Skan tree type; 388790075Sobrien int saved_wsp = warn_strict_prototypes; 388890075Sobrien 388990075Sobrien /* This avoids warnings about unprototyped casts on 389090075Sobrien integers. E.g. "#define SIG_DFL (void(*)())0". */ 389190075Sobrien if (TREE_CODE (expr) == INTEGER_CST) 389290075Sobrien warn_strict_prototypes = 0; 3893169689Skan type = groktypename (type_name); 389490075Sobrien warn_strict_prototypes = saved_wsp; 389590075Sobrien 389690075Sobrien return build_c_cast (type, expr); 389790075Sobrien} 389818334Speter 389918334Speter/* Build an assignment expression of lvalue LHS from value RHS. 390018334Speter MODIFYCODE is the code for a binary operator that we use 390118334Speter to combine the old value of LHS with RHS to get the new value. 390218334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 390318334Speter 390418334Spetertree 3905132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 390618334Speter{ 390790075Sobrien tree result; 390818334Speter tree newrhs; 390918334Speter tree lhstype = TREE_TYPE (lhs); 391018334Speter tree olhstype = lhstype; 3911260311Spfg /* APPLE LOCAL __block assign sequence point 6639533 */ 3912260311Spfg bool insert_sequence_point = false; 391318334Speter 3914260311Spfg /* APPLE LOCAL begin radar 4426814 */ 3915260311Spfg if (c_dialect_objc () && flag_objc_gc) 3916260311Spfg { 3917260311Spfg /* APPLE LOCAL radar 5276085 */ 3918260311Spfg objc_weak_reference_expr (&lhs); 3919260311Spfg lhstype = TREE_TYPE (lhs); 3920260311Spfg olhstype = lhstype; 3921260311Spfg } 3922260311Spfg /* APPLE LOCAL end radar 4426814 */ 3923260311Spfg 392418334Speter /* Types that aren't fully specified cannot be used in assignments. */ 392518334Speter lhs = require_complete_type (lhs); 392618334Speter 392718334Speter /* Avoid duplicate error messages from operands that had errors. */ 392818334Speter if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 392918334Speter return error_mark_node; 393018334Speter 3931260311Spfg /* APPLE LOCAL radar 5285911 */ 3932169689Skan if (!lvalue_or_else (lhs, lv_assign)) 3933169689Skan return error_mark_node; 393418334Speter 3935169689Skan STRIP_TYPE_NOPS (rhs); 3936169689Skan 3937260311Spfg /* APPLE LOCAL begin __block assign sequence point 6639533 */ 3938260311Spfg /* For byref = x;, we have to transform this into {( typeof(x) x' = 3939260311Spfg x; byref = x`; )} to ensure there is a sequence point before the 3940260311Spfg evaluation of the byref, inorder to ensure that the access 3941260311Spfg expression for byref doesn't start running before x is evaluated, 3942260311Spfg as it will access the __forwarding pointer and that must be done 3943260311Spfg after x is evaluated. */ 3944260311Spfg /* First we check to see if lhs is a byref... byrefs look like: 3945260311Spfg __Block_byref_X.__forwarding->x */ 3946260311Spfg if (TREE_CODE (lhs) == COMPONENT_REF) 3947260311Spfg { 3948260311Spfg tree inner = TREE_OPERAND (lhs, 0); 3949260311Spfg /* now check for -> */ 3950260311Spfg if (TREE_CODE (inner) == INDIRECT_REF) 3951260311Spfg { 3952260311Spfg inner = TREE_OPERAND (inner, 0); 3953260311Spfg if (TREE_CODE (inner) == COMPONENT_REF) 3954260311Spfg { 3955260311Spfg inner = TREE_OPERAND (inner, 0); 3956260311Spfg if (TREE_CODE (inner) == VAR_DECL 3957260311Spfg && COPYABLE_BYREF_LOCAL_VAR (inner)) 3958260311Spfg { 3959260311Spfg tree old_rhs = rhs; 3960260311Spfg /* then we save the rhs. */ 3961260311Spfg rhs = save_expr (rhs); 3962260311Spfg if (rhs != old_rhs) 3963260311Spfg /* And arrange for the sequence point to be inserted. */ 3964260311Spfg insert_sequence_point = true; 3965260311Spfg } 3966260311Spfg } 3967260311Spfg } 3968260311Spfg } 3969260311Spfg /* APPLE LOCAL end __block assign sequence point 6639533 */ 3970260311Spfg 397118334Speter newrhs = rhs; 397218334Speter 397318334Speter /* If a binary op has been requested, combine the old LHS value with the RHS 397418334Speter producing the value we should actually store into the LHS. */ 397518334Speter 397618334Speter if (modifycode != NOP_EXPR) 397718334Speter { 397818334Speter lhs = stabilize_reference (lhs); 397918334Speter newrhs = build_binary_op (modifycode, lhs, rhs, 1); 398018334Speter } 398118334Speter 3982260311Spfg /* APPLE LOCAL begin C* property (Radar 4436866) */ 3983260311Spfg if (c_dialect_objc ()) 3984260311Spfg { 3985260311Spfg result = objc_build_setter_call (lhs, newrhs); 3986260311Spfg if (result) 3987260311Spfg /* APPLE LOCAL begin __block assign sequence point 6639533 */ 3988260311Spfg { 3989260311Spfg if (insert_sequence_point) 3990260311Spfg result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 3991260311Spfg return result; 3992260311Spfg } 3993260311Spfg /* APPLE LOCAL end __block assign sequence point 6639533 */ 3994260311Spfg } 3995260311Spfg /* APPLE LOCAL end C* property (Radar 4436866) */ 3996260311Spfg 3997169689Skan /* Give an error for storing in something that is 'const'. */ 399818334Speter 399918334Speter if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 400018334Speter || ((TREE_CODE (lhstype) == RECORD_TYPE 400118334Speter || TREE_CODE (lhstype) == UNION_TYPE) 400218334Speter && C_TYPE_FIELDS_READONLY (lhstype))) 4003169689Skan { 4004169689Skan readonly_error (lhs, lv_assign); 4005169689Skan return error_mark_node; 4006169689Skan } 400718334Speter 400818334Speter /* If storing into a structure or union member, 400918334Speter it has probably been given type `int'. 401018334Speter Compute the type that would go with 401118334Speter the actual amount of storage the member occupies. */ 401218334Speter 401318334Speter if (TREE_CODE (lhs) == COMPONENT_REF 401418334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 401590075Sobrien || TREE_CODE (lhstype) == BOOLEAN_TYPE 401618334Speter || TREE_CODE (lhstype) == REAL_TYPE 401718334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 401818334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 401918334Speter 402018334Speter /* If storing in a field that is in actuality a short or narrower than one, 402118334Speter we must store in the field in its actual type. */ 402218334Speter 402318334Speter if (lhstype != TREE_TYPE (lhs)) 402418334Speter { 402518334Speter lhs = copy_node (lhs); 402618334Speter TREE_TYPE (lhs) = lhstype; 402718334Speter } 402818334Speter 402918334Speter /* Convert new value to destination type. */ 403018334Speter 4031169689Skan newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 403218334Speter NULL_TREE, NULL_TREE, 0); 403318334Speter if (TREE_CODE (newrhs) == ERROR_MARK) 403418334Speter return error_mark_node; 403518334Speter 4036169689Skan /* Emit ObjC write barrier, if necessary. */ 4037169689Skan if (c_dialect_objc () && flag_objc_gc) 4038169689Skan { 4039169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 4040169689Skan if (result) 4041260311Spfg /* APPLE LOCAL begin __block assign sequence point 6639533 */ 4042260311Spfg { 4043260311Spfg if (insert_sequence_point) 4044260311Spfg result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 4045260311Spfg return result; 4046260311Spfg } 4047260311Spfg /* APPLE LOCAL end __block assign sequence point 6639533 */ 4048169689Skan } 404990075Sobrien 4050169689Skan /* Scan operands. */ 4051169689Skan 4052169689Skan result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 405318334Speter TREE_SIDE_EFFECTS (result) = 1; 405418334Speter 4055260311Spfg /* APPLE LOCAL begin __block assign sequence point 6639533 */ 4056260311Spfg if (insert_sequence_point) 4057260311Spfg result = build2 (COMPOUND_EXPR, TREE_TYPE (result), build1 (NOP_EXPR, void_type_node, rhs), result); 4058260311Spfg /* APPLE LOCAL end __block assign sequence point 6639533 */ 4059260311Spfg 406018334Speter /* If we got the LHS in a different type for storing in, 406118334Speter convert the result back to the nominal type of LHS 406218334Speter so that the value we return always has the same type 406318334Speter as the LHS argument. */ 406418334Speter 406518334Speter if (olhstype == TREE_TYPE (result)) 406618334Speter return result; 4067169689Skan return convert_for_assignment (olhstype, result, ic_assign, 406818334Speter NULL_TREE, NULL_TREE, 0); 406918334Speter} 407018334Speter 407118334Speter/* Convert value RHS to type TYPE as preparation for an assignment 407218334Speter to an lvalue of type TYPE. 407318334Speter The real work of conversion is done by `convert'. 407418334Speter The purpose of this function is to generate error messages 407518334Speter for assignments that are not allowed in C. 4076169689Skan ERRTYPE says whether it is argument passing, assignment, 4077169689Skan initialization or return. 407818334Speter 4079169689Skan FUNCTION is a tree for the function being called. 408018334Speter PARMNUM is the number of the argument, for printing in error messages. */ 408118334Speter 408218334Speterstatic tree 4083169689Skanconvert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 4084169689Skan tree fundecl, tree function, int parmnum) 408518334Speter{ 408690075Sobrien enum tree_code codel = TREE_CODE (type); 408790075Sobrien tree rhstype; 408890075Sobrien enum tree_code coder; 4089169689Skan tree rname = NULL_TREE; 4090169689Skan bool objc_ok = false; 409118334Speter 4092169689Skan if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 4093169689Skan { 4094169689Skan tree selector; 4095169689Skan /* Change pointer to function to the function itself for 4096169689Skan diagnostics. */ 4097169689Skan if (TREE_CODE (function) == ADDR_EXPR 4098169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 4099169689Skan function = TREE_OPERAND (function, 0); 410018334Speter 4101169689Skan /* Handle an ObjC selector specially for diagnostics. */ 4102169689Skan selector = objc_message_selector (); 4103169689Skan rname = function; 4104169689Skan if (selector && parmnum > 2) 4105169689Skan { 4106169689Skan rname = selector; 4107169689Skan parmnum -= 2; 4108169689Skan } 4109169689Skan } 4110169689Skan 4111169689Skan /* This macro is used to emit diagnostics to ensure that all format 4112169689Skan strings are complete sentences, visible to gettext and checked at 4113169689Skan compile time. */ 4114169689Skan#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 4115169689Skan do { \ 4116169689Skan switch (errtype) \ 4117169689Skan { \ 4118169689Skan case ic_argpass: \ 4119169689Skan pedwarn (AR, parmnum, rname); \ 4120169689Skan break; \ 4121169689Skan case ic_argpass_nonproto: \ 4122169689Skan warning (0, AR, parmnum, rname); \ 4123169689Skan break; \ 4124169689Skan case ic_assign: \ 4125169689Skan pedwarn (AS); \ 4126169689Skan break; \ 4127169689Skan case ic_init: \ 4128169689Skan pedwarn (IN); \ 4129169689Skan break; \ 4130169689Skan case ic_return: \ 4131169689Skan pedwarn (RE); \ 4132169689Skan break; \ 4133169689Skan default: \ 4134169689Skan gcc_unreachable (); \ 4135169689Skan } \ 4136169689Skan } while (0) 4137169689Skan 4138169689Skan STRIP_TYPE_NOPS (rhs); 4139169689Skan 4140169689Skan if (optimize && TREE_CODE (rhs) == VAR_DECL 4141169689Skan && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 414290075Sobrien rhs = decl_constant_value_for_broken_optimization (rhs); 414318334Speter 414418334Speter rhstype = TREE_TYPE (rhs); 414518334Speter coder = TREE_CODE (rhstype); 414618334Speter 414718334Speter if (coder == ERROR_MARK) 414818334Speter return error_mark_node; 414918334Speter 4150169689Skan if (c_dialect_objc ()) 4151169689Skan { 4152169689Skan int parmno; 4153169689Skan 4154169689Skan switch (errtype) 4155169689Skan { 4156169689Skan case ic_return: 4157169689Skan parmno = 0; 4158169689Skan break; 4159169689Skan 4160169689Skan case ic_assign: 4161169689Skan parmno = -1; 4162169689Skan break; 4163169689Skan 4164169689Skan case ic_init: 4165169689Skan parmno = -2; 4166169689Skan break; 4167169689Skan 4168169689Skan default: 4169169689Skan parmno = parmnum; 4170169689Skan break; 4171169689Skan } 4172169689Skan 4173260311Spfg /* APPLE LOCAL radar 6231433 */ 4174260311Spfg objc_ok = objc_compare_types (type, rhstype, parmno, rname, "comparison"); 4175169689Skan } 4176169689Skan 417718334Speter if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 4178258731Spfg return rhs; 417918334Speter 418018334Speter if (coder == VOID_TYPE) 418118334Speter { 4182169689Skan /* Except for passing an argument to an unprototyped function, 4183169689Skan this is a constraint violation. When passing an argument to 4184169689Skan an unprototyped function, it is compile-time undefined; 4185169689Skan making it a constraint in that case was rejected in 4186169689Skan DR#252. */ 418718334Speter error ("void value not ignored as it ought to be"); 418818334Speter return error_mark_node; 418918334Speter } 4190132718Skan /* A type converts to a reference to it. 419190075Sobrien This code doesn't fully support references, it's just for the 419290075Sobrien special case of va_start and va_copy. */ 419390075Sobrien if (codel == REFERENCE_TYPE 4194260311Spfg /* APPLE LOCAL begin radar 4502186 */ 4195260311Spfg && comptypes (objc_non_volatilized_type (TREE_TYPE (type)), 4196260311Spfg objc_non_volatilized_type (TREE_TYPE (rhs))) == 1) 4197260311Spfg /* APPLE LOCAL end radar 4502186 */ 419890075Sobrien { 4199117395Skan if (!lvalue_p (rhs)) 4200117395Skan { 4201117395Skan error ("cannot pass rvalue to reference parameter"); 4202117395Skan return error_mark_node; 4203117395Skan } 4204117395Skan if (!c_mark_addressable (rhs)) 420590075Sobrien return error_mark_node; 420690075Sobrien rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 420790075Sobrien 420890075Sobrien /* We already know that these two types are compatible, but they 420990075Sobrien may not be exactly identical. In fact, `TREE_TYPE (type)' is 421090075Sobrien likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 421190075Sobrien likely to be va_list, a typedef to __builtin_va_list, which 421290075Sobrien is different enough that it will cause problems later. */ 421390075Sobrien if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 421490075Sobrien rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 421590075Sobrien 421690075Sobrien rhs = build1 (NOP_EXPR, type, rhs); 421790075Sobrien return rhs; 421890075Sobrien } 4219132718Skan /* Some types can interconvert without explicit casts. */ 4220132718Skan else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 4221259005Spfg && vector_types_convertible_p (type, TREE_TYPE (rhs), true)) 4222132718Skan return convert (type, rhs); 422318334Speter /* Arithmetic types all interconvert, and enum is treated like int. */ 4224132718Skan else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 422590075Sobrien || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 422690075Sobrien || codel == BOOLEAN_TYPE) 4227117395Skan && (coder == INTEGER_TYPE || coder == REAL_TYPE 422890075Sobrien || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 422990075Sobrien || coder == BOOLEAN_TYPE)) 423018334Speter return convert_and_check (type, rhs); 423118334Speter 4232169689Skan /* Aggregates in different TUs might need conversion. */ 4233169689Skan if ((codel == RECORD_TYPE || codel == UNION_TYPE) 4234169689Skan && codel == coder 4235169689Skan && comptypes (type, rhstype)) 4236169689Skan return convert_and_check (type, rhs); 4237169689Skan 423850397Sobrien /* Conversion to a transparent union from its member types. 423950397Sobrien This applies only to function arguments. */ 4240169689Skan if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 4241169689Skan && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 424218334Speter { 4243169689Skan tree memb, marginal_memb = NULL_TREE; 424418334Speter 4245169689Skan for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 424618334Speter { 4247169689Skan tree memb_type = TREE_TYPE (memb); 424818334Speter 424950397Sobrien if (comptypes (TYPE_MAIN_VARIANT (memb_type), 4250169689Skan TYPE_MAIN_VARIANT (rhstype))) 425150397Sobrien break; 425250397Sobrien 425350397Sobrien if (TREE_CODE (memb_type) != POINTER_TYPE) 425450397Sobrien continue; 425550397Sobrien 425650397Sobrien if (coder == POINTER_TYPE) 425718334Speter { 425890075Sobrien tree ttl = TREE_TYPE (memb_type); 425990075Sobrien tree ttr = TREE_TYPE (rhstype); 426018334Speter 426118334Speter /* Any non-function converts to a [const][volatile] void * 426218334Speter and vice versa; otherwise, targets must be the same. 426318334Speter Meanwhile, the lhs target must have all the qualifiers of 426418334Speter the rhs. */ 426590075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4266169689Skan || comp_target_types (memb_type, rhstype)) 426718334Speter { 426850397Sobrien /* If this type won't generate any warnings, use it. */ 426952284Sobrien if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 427052284Sobrien || ((TREE_CODE (ttr) == FUNCTION_TYPE 427152284Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 427252284Sobrien ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 427352284Sobrien == TYPE_QUALS (ttr)) 427452284Sobrien : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 427552284Sobrien == TYPE_QUALS (ttl)))) 427650397Sobrien break; 427718334Speter 427850397Sobrien /* Keep looking for a better type, but remember this one. */ 4279169689Skan if (!marginal_memb) 4280169689Skan marginal_memb = memb; 428118334Speter } 428218334Speter } 428318334Speter 428418334Speter /* Can convert integer zero to any pointer type. */ 4285169689Skan if (null_pointer_constant_p (rhs)) 428650397Sobrien { 428750397Sobrien rhs = null_pointer_node; 428850397Sobrien break; 428950397Sobrien } 429018334Speter } 429150397Sobrien 4292169689Skan if (memb || marginal_memb) 429350397Sobrien { 4294169689Skan if (!memb) 429550397Sobrien { 429650397Sobrien /* We have only a marginally acceptable member type; 429750397Sobrien it needs a warning. */ 4298169689Skan tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 429990075Sobrien tree ttr = TREE_TYPE (rhstype); 430050397Sobrien 430150397Sobrien /* Const and volatile mean something different for function 430250397Sobrien types, so the usual warnings are not appropriate. */ 430350397Sobrien if (TREE_CODE (ttr) == FUNCTION_TYPE 430450397Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 430550397Sobrien { 430650397Sobrien /* Because const and volatile on functions are 430750397Sobrien restrictions that say the function will not do 430850397Sobrien certain things, it is okay to use a const or volatile 430950397Sobrien function where an ordinary one is wanted, but not 431050397Sobrien vice-versa. */ 431152284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4312169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 4313169689Skan "makes qualified function " 4314169689Skan "pointer from unqualified"), 4315169689Skan G_("assignment makes qualified " 4316169689Skan "function pointer from " 4317169689Skan "unqualified"), 4318169689Skan G_("initialization makes qualified " 4319169689Skan "function pointer from " 4320169689Skan "unqualified"), 4321169689Skan G_("return makes qualified function " 4322169689Skan "pointer from unqualified")); 432350397Sobrien } 432452284Sobrien else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4325169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4326169689Skan "qualifiers from pointer target type"), 4327169689Skan G_("assignment discards qualifiers " 4328169689Skan "from pointer target type"), 4329169689Skan G_("initialization discards qualifiers " 4330169689Skan "from pointer target type"), 4331169689Skan G_("return discards qualifiers from " 4332169689Skan "pointer target type")); 4333169689Skan 4334169689Skan memb = marginal_memb; 433550397Sobrien } 4336132718Skan 4337169689Skan if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 433890075Sobrien pedwarn ("ISO C prohibits argument conversion to union type"); 433950397Sobrien 4340169689Skan return build_constructor_single (type, memb, rhs); 434150397Sobrien } 434218334Speter } 434318334Speter 434418334Speter /* Conversions among pointers */ 434590075Sobrien else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4346117395Skan && (coder == codel)) 434718334Speter { 4348260311Spfg /* APPLE LOCAL begin radar 4193359 */ 4349260311Spfg /* Types differing only by the presence of the 'volatile' 4350260311Spfg qualifier are acceptable if the 'volatile' has been added 4351260311Spfg in by the Objective-C EH machinery. */ 4352260311Spfg tree ttl = objc_non_volatilized_type (TREE_TYPE (type)); 4353260311Spfg tree ttr = objc_non_volatilized_type (TREE_TYPE (rhstype)); 4354260311Spfg /* APPLE LOCAL end radar 4193359 */ 4355169689Skan tree mvl = ttl; 4356169689Skan tree mvr = ttr; 4357132718Skan bool is_opaque_pointer; 4358132718Skan int target_cmp = 0; /* Cache comp_target_types () result. */ 435918334Speter 4360169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 4361169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 4362169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 4363169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 4364132718Skan /* Opaque pointers are treated like void pointers. */ 4365169689Skan is_opaque_pointer = (targetm.vector_opaque_p (type) 4366169689Skan || targetm.vector_opaque_p (rhstype)) 4367169689Skan && TREE_CODE (ttl) == VECTOR_TYPE 4368169689Skan && TREE_CODE (ttr) == VECTOR_TYPE; 4369132718Skan 4370169689Skan /* C++ does not allow the implicit conversion void* -> T*. However, 4371169689Skan for the purpose of reducing the number of false positives, we 4372169689Skan tolerate the special case of 4373169689Skan 4374169689Skan int *p = NULL; 4375169689Skan 4376169689Skan where NULL is typically defined in C to be '(void *) 0'. */ 4377169689Skan if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4378169689Skan warning (OPT_Wc___compat, "request for implicit conversion from " 4379169689Skan "%qT to %qT not permitted in C++", rhstype, type); 4380169689Skan 4381169689Skan /* Check if the right-hand side has a format attribute but the 4382169689Skan left-hand side doesn't. */ 4383169689Skan if (warn_missing_format_attribute 4384169689Skan && check_missing_format_attribute (type, rhstype)) 4385169689Skan { 4386169689Skan switch (errtype) 4387169689Skan { 4388169689Skan case ic_argpass: 4389169689Skan case ic_argpass_nonproto: 4390169689Skan warning (OPT_Wmissing_format_attribute, 4391169689Skan "argument %d of %qE might be " 4392169689Skan "a candidate for a format attribute", 4393169689Skan parmnum, rname); 4394169689Skan break; 4395169689Skan case ic_assign: 4396169689Skan warning (OPT_Wmissing_format_attribute, 4397169689Skan "assignment left-hand side might be " 4398169689Skan "a candidate for a format attribute"); 4399169689Skan break; 4400169689Skan case ic_init: 4401169689Skan warning (OPT_Wmissing_format_attribute, 4402169689Skan "initialization left-hand side might be " 4403169689Skan "a candidate for a format attribute"); 4404169689Skan break; 4405169689Skan case ic_return: 4406169689Skan warning (OPT_Wmissing_format_attribute, 4407169689Skan "return type might be " 4408169689Skan "a candidate for a format attribute"); 4409169689Skan break; 4410169689Skan default: 4411169689Skan gcc_unreachable (); 4412169689Skan } 4413169689Skan } 4414169689Skan 441518334Speter /* Any non-function converts to a [const][volatile] void * 441618334Speter and vice versa; otherwise, targets must be the same. 441718334Speter Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 441890075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4419169689Skan || (target_cmp = comp_target_types (type, rhstype)) 4420132718Skan || is_opaque_pointer 4421169689Skan || (c_common_unsigned_type (mvl) 4422169689Skan == c_common_unsigned_type (mvr))) 442318334Speter { 442418334Speter if (pedantic 442590075Sobrien && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 442618334Speter || 442790075Sobrien (VOID_TYPE_P (ttr) 4428169689Skan && !null_pointer_constant_p (rhs) 442918334Speter && TREE_CODE (ttl) == FUNCTION_TYPE))) 4430169689Skan WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4431169689Skan "%qE between function pointer " 4432169689Skan "and %<void *%>"), 4433169689Skan G_("ISO C forbids assignment between " 4434169689Skan "function pointer and %<void *%>"), 4435169689Skan G_("ISO C forbids initialization between " 4436169689Skan "function pointer and %<void *%>"), 4437169689Skan G_("ISO C forbids return between function " 4438169689Skan "pointer and %<void *%>")); 443918334Speter /* Const and volatile mean something different for function types, 444018334Speter so the usual warnings are not appropriate. */ 444118334Speter else if (TREE_CODE (ttr) != FUNCTION_TYPE 444218334Speter && TREE_CODE (ttl) != FUNCTION_TYPE) 444318334Speter { 444452284Sobrien if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4445169689Skan { 4446260311Spfg /* APPLE LOCAL begin radar 4193359 */ 4447169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4448169689Skan "qualifiers from pointer target type"), 4449169689Skan G_("assignment discards qualifiers " 4450169689Skan "from pointer target type"), 4451169689Skan G_("initialization discards qualifiers " 4452169689Skan "from pointer target type"), 4453169689Skan G_("return discards qualifiers from " 4454169689Skan "pointer target type")); 4455169689Skan } 445618334Speter /* If this is not a case of ignoring a mismatch in signedness, 445718334Speter no warning. */ 445890075Sobrien else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4459132718Skan || target_cmp) 446018334Speter ; 446118334Speter /* If there is a mismatch, do warn. */ 4462169689Skan else if (warn_pointer_sign) 4463169689Skan WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4464169689Skan "%d of %qE differ in signedness"), 4465169689Skan G_("pointer targets in assignment " 4466169689Skan "differ in signedness"), 4467169689Skan G_("pointer targets in initialization " 4468169689Skan "differ in signedness"), 4469169689Skan G_("pointer targets in return differ " 4470169689Skan "in signedness")); 447118334Speter } 447218334Speter else if (TREE_CODE (ttl) == FUNCTION_TYPE 447318334Speter && TREE_CODE (ttr) == FUNCTION_TYPE) 447418334Speter { 447518334Speter /* Because const and volatile on functions are restrictions 447618334Speter that say the function will not do certain things, 447718334Speter it is okay to use a const or volatile function 447818334Speter where an ordinary one is wanted, but not vice-versa. */ 447952284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4480169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4481169689Skan "qualified function pointer " 4482169689Skan "from unqualified"), 4483169689Skan G_("assignment makes qualified function " 4484169689Skan "pointer from unqualified"), 4485169689Skan G_("initialization makes qualified " 4486169689Skan "function pointer from unqualified"), 4487169689Skan G_("return makes qualified function " 4488169689Skan "pointer from unqualified")); 448918334Speter } 449018334Speter } 449118334Speter else 4492169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 4493169689Skan if (!objc_ok) 4494169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4495169689Skan "incompatible pointer type"), 4496169689Skan G_("assignment from incompatible pointer type"), 4497169689Skan G_("initialization from incompatible " 4498169689Skan "pointer type"), 4499169689Skan G_("return from incompatible pointer type")); 4500169689Skan 450118334Speter return convert (type, rhs); 450218334Speter } 4503122180Skan else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4504122180Skan { 4505169689Skan /* ??? This should not be an error when inlining calls to 4506169689Skan unprototyped functions. */ 4507122180Skan error ("invalid use of non-lvalue array"); 4508122180Skan return error_mark_node; 4509122180Skan } 451018334Speter else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 451118334Speter { 451218334Speter /* An explicit constant 0 can convert to a pointer, 451318334Speter or one that results from arithmetic, even including 451418334Speter a cast to integer type. */ 4515169689Skan if (!null_pointer_constant_p (rhs)) 4516169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4517169689Skan "pointer from integer without a cast"), 4518169689Skan G_("assignment makes pointer from integer " 4519169689Skan "without a cast"), 4520169689Skan G_("initialization makes pointer from " 4521169689Skan "integer without a cast"), 4522169689Skan G_("return makes pointer from integer " 4523169689Skan "without a cast")); 4524132718Skan 4525132718Skan return convert (type, rhs); 452618334Speter } 4527260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 4528260311Spfg else if (codel == BLOCK_POINTER_TYPE && coder == INTEGER_TYPE) 4529260311Spfg { 4530260311Spfg if (!null_pointer_constant_p (rhs)) 4531260311Spfg { 4532260311Spfg error("invalid conversion %s integer 'int', expected block pointer", 4533260311Spfg errtype == ic_assign ? "assigning" : "initializing"); 4534260311Spfg return error_mark_node; 4535260311Spfg } 4536260311Spfg return build_int_cst (type, 0); 4537260311Spfg } 4538260311Spfg else if (codel == BLOCK_POINTER_TYPE && coder == codel) 4539260311Spfg { 4540260311Spfg tree lhptee = TREE_TYPE (type); 4541260311Spfg tree rhptee = TREE_TYPE(rhstype); 4542260311Spfg if (lhptee == rhptee) 4543260311Spfg return rhs; 4544260311Spfg if (!types_are_block_compatible (lhptee, rhptee)) 4545260311Spfg { 4546260311Spfg error ("incompatible block pointer types %s %qT, expected %qT", 4547260311Spfg errtype == ic_assign ? "assigning" : "initializing", 4548260311Spfg rhstype, type); 4549260311Spfg return error_mark_node; 4550260311Spfg } 4551260311Spfg return rhs; 4552260311Spfg } 4553260311Spfg /* APPLE LOCAL begin radar 5831855 */ 4554260311Spfg /* APPLE LOCAL radar 5878380 */ 4555260311Spfg else if (codel == BLOCK_POINTER_TYPE && POINTER_TYPE_P (rhstype) && 4556260311Spfg (VOID_TYPE_P (TREE_TYPE (rhstype)) || objc_is_id (rhstype))) 4557260311Spfg return convert (type, rhs); 4558260311Spfg /* APPLE LOCAL radar 5878380 */ 4559260311Spfg else if (coder == BLOCK_POINTER_TYPE && POINTER_TYPE_P (type) && 4560260311Spfg (VOID_TYPE_P (TREE_TYPE (type)) || objc_is_id (type))) 4561260311Spfg /* APPLE LOCAL end radar 5831855 */ 4562260311Spfg return convert (type, rhs); 4563260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 456418334Speter else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 456518334Speter { 4566169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4567169689Skan "from pointer without a cast"), 4568169689Skan G_("assignment makes integer from pointer " 4569169689Skan "without a cast"), 4570169689Skan G_("initialization makes integer from pointer " 4571169689Skan "without a cast"), 4572169689Skan G_("return makes integer from pointer " 4573169689Skan "without a cast")); 457418334Speter return convert (type, rhs); 457518334Speter } 457690075Sobrien else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 457790075Sobrien return convert (type, rhs); 457818334Speter 4579169689Skan switch (errtype) 458018334Speter { 4581169689Skan case ic_argpass: 4582169689Skan case ic_argpass_nonproto: 4583169689Skan /* ??? This should not be an error when inlining calls to 4584169689Skan unprototyped functions. */ 4585260311Spfg error ("convert_for_assignment: incompatible type for argument %d of %qE", parmnum, rname); 4586169689Skan break; 4587169689Skan case ic_assign: 4588169689Skan error ("incompatible types in assignment"); 4589169689Skan break; 4590169689Skan case ic_init: 4591169689Skan error ("incompatible types in initialization"); 4592169689Skan break; 4593169689Skan case ic_return: 4594169689Skan error ("incompatible types in return"); 4595169689Skan break; 4596169689Skan default: 4597169689Skan gcc_unreachable (); 459818334Speter } 459918334Speter 460018334Speter return error_mark_node; 460118334Speter} 460218334Speter 4603132718Skan/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4604169689Skan is used for error and warning reporting and indicates which argument 4605132718Skan is being processed. */ 460696263Sobrien 460796263Sobrientree 4608132718Skanc_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 460996263Sobrien{ 461096263Sobrien tree ret, type; 461196263Sobrien 4612169689Skan /* If FN was prototyped at the call site, the value has been converted 4613169689Skan already in convert_arguments. 4614169689Skan However, we might see a prototype now that was not in place when 4615169689Skan the function call was seen, so check that the VALUE actually matches 4616169689Skan PARM before taking an early exit. */ 4617169689Skan if (!value 4618169689Skan || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4619169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4620169689Skan == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 462196263Sobrien return value; 462296263Sobrien 462396263Sobrien type = TREE_TYPE (parm); 4624132718Skan ret = convert_for_assignment (type, value, 4625169689Skan ic_argpass_nonproto, fn, 4626169689Skan fn, argnum); 4627132718Skan if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 462896263Sobrien && INTEGRAL_TYPE_P (type) 462996263Sobrien && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 463096263Sobrien ret = default_conversion (ret); 463196263Sobrien return ret; 463296263Sobrien} 463318334Speter 463418334Speter/* If VALUE is a compound expr all of whose expressions are constant, then 463518334Speter return its value. Otherwise, return error_mark_node. 463618334Speter 463718334Speter This is for handling COMPOUND_EXPRs as initializer elements 463818334Speter which is allowed with a warning when -pedantic is specified. */ 463918334Speter 464018334Speterstatic tree 4641132718Skanvalid_compound_expr_initializer (tree value, tree endtype) 464218334Speter{ 464318334Speter if (TREE_CODE (value) == COMPOUND_EXPR) 464418334Speter { 464518334Speter if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 464618334Speter == error_mark_node) 464718334Speter return error_mark_node; 464818334Speter return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 464918334Speter endtype); 465018334Speter } 4651169689Skan else if (!initializer_constant_valid_p (value, endtype)) 465218334Speter return error_mark_node; 465318334Speter else 465418334Speter return value; 465518334Speter} 465618334Speter 465718334Speter/* Perform appropriate conversions on the initial value of a variable, 465818334Speter store it in the declaration DECL, 465918334Speter and print any error messages that are appropriate. 466018334Speter If the init is invalid, store an ERROR_MARK. */ 466118334Speter 466218334Spetervoid 4663132718Skanstore_init_value (tree decl, tree init) 466418334Speter{ 466590075Sobrien tree value, type; 466618334Speter 466718334Speter /* If variable's type was invalidly declared, just ignore it. */ 466818334Speter 466918334Speter type = TREE_TYPE (decl); 467018334Speter if (TREE_CODE (type) == ERROR_MARK) 467118334Speter return; 467218334Speter 467318334Speter /* Digest the specified initializer into an expression. */ 467418334Speter 4675169689Skan value = digest_init (type, init, true, TREE_STATIC (decl)); 467618334Speter 467718334Speter /* Store the expression if valid; else report error. */ 467818334Speter 4679169689Skan if (!in_system_header 4680169689Skan && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4681169689Skan warning (OPT_Wtraditional, "traditional C rejects automatic " 4682169689Skan "aggregate initialization"); 468390075Sobrien 468418334Speter DECL_INITIAL (decl) = value; 468518334Speter 468618334Speter /* ANSI wants warnings about out-of-range constant initializers. */ 468718334Speter STRIP_TYPE_NOPS (value); 468818334Speter constant_expression_warning (value); 468990075Sobrien 469090075Sobrien /* Check if we need to set array size from compound literal size. */ 469190075Sobrien if (TREE_CODE (type) == ARRAY_TYPE 469290075Sobrien && TYPE_DOMAIN (type) == 0 469390075Sobrien && value != error_mark_node) 469490075Sobrien { 469590075Sobrien tree inside_init = init; 469690075Sobrien 4697169689Skan STRIP_TYPE_NOPS (inside_init); 469890075Sobrien inside_init = fold (inside_init); 469990075Sobrien 470090075Sobrien if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 470190075Sobrien { 4702169689Skan tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 470390075Sobrien 4704169689Skan if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 470590075Sobrien { 470690075Sobrien /* For int foo[] = (int [3]){1}; we need to set array size 470790075Sobrien now since later on array initializer will be just the 470890075Sobrien brace enclosed list of the compound literal. */ 4709169689Skan type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4710169689Skan TREE_TYPE (decl) = type; 4711169689Skan TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 471290075Sobrien layout_type (type); 4713169689Skan layout_decl (cldecl, 0); 471490075Sobrien } 471590075Sobrien } 471690075Sobrien } 471718334Speter} 471818334Speter 471918334Speter/* Methods for storing and printing names for error messages. */ 472018334Speter 472118334Speter/* Implement a spelling stack that allows components of a name to be pushed 472218334Speter and popped. Each element on the stack is this structure. */ 472318334Speter 472418334Speterstruct spelling 472518334Speter{ 472618334Speter int kind; 472718334Speter union 472818334Speter { 4729169689Skan unsigned HOST_WIDE_INT i; 473052284Sobrien const char *s; 473118334Speter } u; 473218334Speter}; 473318334Speter 473418334Speter#define SPELLING_STRING 1 473518334Speter#define SPELLING_MEMBER 2 473618334Speter#define SPELLING_BOUNDS 3 473718334Speter 473818334Speterstatic struct spelling *spelling; /* Next stack element (unused). */ 473918334Speterstatic struct spelling *spelling_base; /* Spelling stack base. */ 474018334Speterstatic int spelling_size; /* Size of the spelling stack. */ 474118334Speter 474218334Speter/* Macros to save and restore the spelling stack around push_... functions. 474318334Speter Alternative to SAVE_SPELLING_STACK. */ 474418334Speter 474518334Speter#define SPELLING_DEPTH() (spelling - spelling_base) 474690075Sobrien#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 474718334Speter 474818334Speter/* Push an element on the spelling stack with type KIND and assign VALUE 474918334Speter to MEMBER. */ 475018334Speter 475118334Speter#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 475218334Speter{ \ 475318334Speter int depth = SPELLING_DEPTH (); \ 475418334Speter \ 475518334Speter if (depth >= spelling_size) \ 475618334Speter { \ 475718334Speter spelling_size += 10; \ 4758169689Skan spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4759169689Skan spelling_size); \ 476018334Speter RESTORE_SPELLING_DEPTH (depth); \ 476118334Speter } \ 476218334Speter \ 476318334Speter spelling->kind = (KIND); \ 476418334Speter spelling->MEMBER = (VALUE); \ 476518334Speter spelling++; \ 476618334Speter} 476718334Speter 476818334Speter/* Push STRING on the stack. Printed literally. */ 476918334Speter 477018334Speterstatic void 4771132718Skanpush_string (const char *string) 477218334Speter{ 477318334Speter PUSH_SPELLING (SPELLING_STRING, string, u.s); 477418334Speter} 477518334Speter 477618334Speter/* Push a member name on the stack. Printed as '.' STRING. */ 477718334Speter 477818334Speterstatic void 4779132718Skanpush_member_name (tree decl) 478018334Speter{ 478190075Sobrien const char *const string 478218334Speter = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 478318334Speter PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 478418334Speter} 478518334Speter 478618334Speter/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 478718334Speter 478818334Speterstatic void 4789169689Skanpush_array_bounds (unsigned HOST_WIDE_INT bounds) 479018334Speter{ 479118334Speter PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 479218334Speter} 479318334Speter 479418334Speter/* Compute the maximum size in bytes of the printed spelling. */ 479518334Speter 479618334Speterstatic int 4797132718Skanspelling_length (void) 479818334Speter{ 479990075Sobrien int size = 0; 480090075Sobrien struct spelling *p; 480118334Speter 480218334Speter for (p = spelling_base; p < spelling; p++) 480318334Speter { 480418334Speter if (p->kind == SPELLING_BOUNDS) 480518334Speter size += 25; 480618334Speter else 480718334Speter size += strlen (p->u.s) + 1; 480818334Speter } 480918334Speter 481018334Speter return size; 481118334Speter} 481218334Speter 481318334Speter/* Print the spelling to BUFFER and return it. */ 481418334Speter 481518334Speterstatic char * 4816132718Skanprint_spelling (char *buffer) 481718334Speter{ 481890075Sobrien char *d = buffer; 481990075Sobrien struct spelling *p; 482018334Speter 482118334Speter for (p = spelling_base; p < spelling; p++) 482218334Speter if (p->kind == SPELLING_BOUNDS) 482318334Speter { 4824169689Skan sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 482518334Speter d += strlen (d); 482618334Speter } 482718334Speter else 482818334Speter { 482990075Sobrien const char *s; 483018334Speter if (p->kind == SPELLING_MEMBER) 483118334Speter *d++ = '.'; 483250397Sobrien for (s = p->u.s; (*d = *s++); d++) 483318334Speter ; 483418334Speter } 483518334Speter *d++ = '\0'; 483618334Speter return buffer; 483718334Speter} 483818334Speter 483918334Speter/* Issue an error message for a bad initializer component. 484052284Sobrien MSGID identifies the message. 484152284Sobrien The component name is taken from the spelling stack. */ 484218334Speter 484318334Spetervoid 4844132718Skanerror_init (const char *msgid) 484518334Speter{ 484652284Sobrien char *ofwhat; 484718334Speter 484890075Sobrien error ("%s", _(msgid)); 4849169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 485018334Speter if (*ofwhat) 4851169689Skan error ("(near initialization for %qs)", ofwhat); 485218334Speter} 485318334Speter 485418334Speter/* Issue a pedantic warning for a bad initializer component. 485552284Sobrien MSGID identifies the message. 485652284Sobrien The component name is taken from the spelling stack. */ 485718334Speter 485818334Spetervoid 4859132718Skanpedwarn_init (const char *msgid) 486018334Speter{ 486152284Sobrien char *ofwhat; 486218334Speter 486390075Sobrien pedwarn ("%s", _(msgid)); 4864169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 486518334Speter if (*ofwhat) 4866169689Skan pedwarn ("(near initialization for %qs)", ofwhat); 486718334Speter} 486818334Speter 486918334Speter/* Issue a warning for a bad initializer component. 487052284Sobrien MSGID identifies the message. 487152284Sobrien The component name is taken from the spelling stack. */ 487218334Speter 487318334Speterstatic void 4874132718Skanwarning_init (const char *msgid) 487518334Speter{ 487652284Sobrien char *ofwhat; 487718334Speter 4878169689Skan warning (0, "%s", _(msgid)); 4879169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 488018334Speter if (*ofwhat) 4881169689Skan warning (0, "(near initialization for %qs)", ofwhat); 488218334Speter} 488318334Speter 4884169689Skan/* If TYPE is an array type and EXPR is a parenthesized string 4885169689Skan constant, warn if pedantic that EXPR is being used to initialize an 4886169689Skan object of type TYPE. */ 4887169689Skan 4888169689Skanvoid 4889169689Skanmaybe_warn_string_init (tree type, struct c_expr expr) 4890169689Skan{ 4891169689Skan if (pedantic 4892169689Skan && TREE_CODE (type) == ARRAY_TYPE 4893169689Skan && TREE_CODE (expr.value) == STRING_CST 4894169689Skan && expr.original_code != STRING_CST) 4895169689Skan pedwarn_init ("array initialized from parenthesized string constant"); 4896169689Skan} 4897169689Skan 4898260311Spfg/* APPLE LOCAL begin radar 5932809 - copyable byref blocks */ 4899260311Spfgtree do_digest_init (tree type, tree init) 4900260311Spfg{ 4901260311Spfg return digest_init (type, init, true, false); 4902260311Spfg} 4903260311Spfg/* APPLE LOCAL end radar 5932809 - copyable byref blocks */ 4904260311Spfg 490518334Speter/* Digest the parser output INIT as an initializer for type TYPE. 490618334Speter Return a C expression of type TYPE to represent the initial value. 490718334Speter 4908169689Skan If INIT is a string constant, STRICT_STRING is true if it is 4909169689Skan unparenthesized or we should not warn here for it being parenthesized. 4910169689Skan For other types of INIT, STRICT_STRING is not used. 4911169689Skan 4912117395Skan REQUIRE_CONSTANT requests an error if non-constant initializers or 4913117395Skan elements are seen. */ 491418334Speter 491518334Speterstatic tree 4916169689Skandigest_init (tree type, tree init, bool strict_string, int require_constant) 491718334Speter{ 491818334Speter enum tree_code code = TREE_CODE (type); 491918334Speter tree inside_init = init; 492018334Speter 492190075Sobrien if (type == error_mark_node 4922169689Skan || !init 492390075Sobrien || init == error_mark_node 492490075Sobrien || TREE_TYPE (init) == error_mark_node) 492590075Sobrien return error_mark_node; 492618334Speter 4927169689Skan STRIP_TYPE_NOPS (inside_init); 492818334Speter 492990075Sobrien inside_init = fold (inside_init); 493090075Sobrien 493118334Speter /* Initialization of an array of chars from a string constant 493218334Speter optionally enclosed in braces. */ 493318334Speter 4934169689Skan if (code == ARRAY_TYPE && inside_init 4935169689Skan && TREE_CODE (inside_init) == STRING_CST) 493618334Speter { 493718334Speter tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4938169689Skan /* Note that an array could be both an array of character type 4939169689Skan and an array of wchar_t if wchar_t is signed char or unsigned 4940169689Skan char. */ 4941169689Skan bool char_array = (typ1 == char_type_node 4942169689Skan || typ1 == signed_char_type_node 4943169689Skan || typ1 == unsigned_char_type_node); 4944169689Skan bool wchar_array = !!comptypes (typ1, wchar_type_node); 4945169689Skan if (char_array || wchar_array) 494618334Speter { 4947169689Skan struct c_expr expr; 4948169689Skan bool char_string; 4949169689Skan expr.value = inside_init; 4950169689Skan expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4951169689Skan maybe_warn_string_init (type, expr); 4952169689Skan 4953169689Skan char_string 4954169689Skan = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4955169689Skan == char_type_node); 4956169689Skan 495718334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4958169689Skan TYPE_MAIN_VARIANT (type))) 495918334Speter return inside_init; 496018334Speter 4961169689Skan if (!wchar_array && !char_string) 496218334Speter { 496352284Sobrien error_init ("char-array initialized from wide string"); 496418334Speter return error_mark_node; 496518334Speter } 4966169689Skan if (char_string && !char_array) 496718334Speter { 4968169689Skan error_init ("wchar_t-array initialized from non-wide string"); 496918334Speter return error_mark_node; 497018334Speter } 497118334Speter 497218334Speter TREE_TYPE (inside_init) = type; 497318334Speter if (TYPE_DOMAIN (type) != 0 497490075Sobrien && TYPE_SIZE (type) != 0 497590075Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 497618334Speter /* Subtract 1 (or sizeof (wchar_t)) 497718334Speter because it's ok to ignore the terminating null char 497818334Speter that is counted in the length of the constant. */ 497990075Sobrien && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 498090075Sobrien TREE_STRING_LENGTH (inside_init) 498190075Sobrien - ((TYPE_PRECISION (typ1) 498290075Sobrien != TYPE_PRECISION (char_type_node)) 498390075Sobrien ? (TYPE_PRECISION (wchar_type_node) 498490075Sobrien / BITS_PER_UNIT) 498590075Sobrien : 1))) 498690075Sobrien pedwarn_init ("initializer-string for array of chars is too long"); 498790075Sobrien 498818334Speter return inside_init; 498918334Speter } 4990169689Skan else if (INTEGRAL_TYPE_P (typ1)) 4991169689Skan { 4992169689Skan error_init ("array of inappropriate type initialized " 4993169689Skan "from string constant"); 4994169689Skan return error_mark_node; 4995169689Skan } 499618334Speter } 4997132718Skan 4998119256Skan /* Build a VECTOR_CST from a *constant* vector constructor. If the 4999119256Skan vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 5000119256Skan below and handle as a constructor. */ 5001146895Skan if (code == VECTOR_TYPE 5002161651Skan && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 5003259005Spfg && vector_types_convertible_p (TREE_TYPE (inside_init), type, true) 5004146895Skan && TREE_CONSTANT (inside_init)) 5005146895Skan { 5006146895Skan if (TREE_CODE (inside_init) == VECTOR_CST 5007146895Skan && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 5008169689Skan TYPE_MAIN_VARIANT (type))) 5009146895Skan return inside_init; 501018334Speter 5011146895Skan if (TREE_CODE (inside_init) == CONSTRUCTOR) 5012146895Skan { 5013169689Skan unsigned HOST_WIDE_INT ix; 5014169689Skan tree value; 5015169689Skan bool constant_p = true; 5016169689Skan 5017169689Skan /* Iterate through elements and check if all constructor 5018169689Skan elements are *_CSTs. */ 5019169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 5020169689Skan if (!CONSTANT_CLASS_P (value)) 5021169689Skan { 5022169689Skan constant_p = false; 5023169689Skan break; 5024169689Skan } 5025169689Skan 5026169689Skan if (constant_p) 5027169689Skan return build_vector_from_ctor (type, 5028169689Skan CONSTRUCTOR_ELTS (inside_init)); 5029169689Skan } 5030146895Skan } 5031146895Skan 503218334Speter /* Any type can be initialized 503318334Speter from an expression of the same type, optionally with braces. */ 503418334Speter 503518334Speter if (inside_init && TREE_TYPE (inside_init) != 0 503618334Speter && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 5037169689Skan TYPE_MAIN_VARIANT (type)) 503818334Speter || (code == ARRAY_TYPE 5039169689Skan && comptypes (TREE_TYPE (inside_init), type)) 504096263Sobrien || (code == VECTOR_TYPE 5041169689Skan && comptypes (TREE_TYPE (inside_init), type)) 504218334Speter || (code == POINTER_TYPE 5043132718Skan && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 504418334Speter && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 5045169689Skan TREE_TYPE (type))))) 504618334Speter { 504790075Sobrien if (code == POINTER_TYPE) 5048122180Skan { 5049122180Skan if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 5050122180Skan { 5051169689Skan if (TREE_CODE (inside_init) == STRING_CST 5052169689Skan || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 5053169689Skan inside_init = array_to_pointer_conversion (inside_init); 5054169689Skan else 5055169689Skan { 5056169689Skan error_init ("invalid use of non-lvalue array"); 5057169689Skan return error_mark_node; 5058169689Skan } 5059122180Skan } 5060169689Skan } 5061132718Skan 5062132718Skan if (code == VECTOR_TYPE) 5063132718Skan /* Although the types are compatible, we may require a 5064132718Skan conversion. */ 5065132718Skan inside_init = convert (type, inside_init); 5066132718Skan 5067169689Skan if (require_constant 5068169689Skan && (code == VECTOR_TYPE || !flag_isoc99) 506990075Sobrien && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 507018334Speter { 507190075Sobrien /* As an extension, allow initializing objects with static storage 507290075Sobrien duration with compound literals (which are then treated just as 5073169689Skan the brace enclosed list they contain). Also allow this for 5074169689Skan vectors, as we can only assign them with compound literals. */ 507590075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 507690075Sobrien inside_init = DECL_INITIAL (decl); 507790075Sobrien } 507890075Sobrien 507990075Sobrien if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 508090075Sobrien && TREE_CODE (inside_init) != CONSTRUCTOR) 508190075Sobrien { 508252284Sobrien error_init ("array initialized from non-constant array expression"); 508318334Speter return error_mark_node; 508418334Speter } 508518334Speter 508618334Speter if (optimize && TREE_CODE (inside_init) == VAR_DECL) 508790075Sobrien inside_init = decl_constant_value_for_broken_optimization (inside_init); 508818334Speter 508918334Speter /* Compound expressions can only occur here if -pedantic or 509018334Speter -pedantic-errors is specified. In the later case, we always want 509118334Speter an error. In the former case, we simply want a warning. */ 509218334Speter if (require_constant && pedantic 509318334Speter && TREE_CODE (inside_init) == COMPOUND_EXPR) 509418334Speter { 509518334Speter inside_init 509618334Speter = valid_compound_expr_initializer (inside_init, 509718334Speter TREE_TYPE (inside_init)); 509818334Speter if (inside_init == error_mark_node) 509952284Sobrien error_init ("initializer element is not constant"); 510018334Speter else 510152284Sobrien pedwarn_init ("initializer element is not constant"); 510218334Speter if (flag_pedantic_errors) 510318334Speter inside_init = error_mark_node; 510418334Speter } 5105132718Skan else if (require_constant 5106169689Skan && !initializer_constant_valid_p (inside_init, 5107169689Skan TREE_TYPE (inside_init))) 510818334Speter { 510952284Sobrien error_init ("initializer element is not constant"); 511018334Speter inside_init = error_mark_node; 511118334Speter } 511218334Speter 5113169689Skan /* Added to enable additional -Wmissing-format-attribute warnings. */ 5114260311Spfg /* APPLE LOCAL begin radar 5822844 */ 5115260311Spfg if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE || 5116260311Spfg TREE_CODE (TREE_TYPE (inside_init)) == BLOCK_POINTER_TYPE) 5117260311Spfg /* APPLE LOCAL end radar 5822844 */ 5118169689Skan inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 5119169689Skan NULL_TREE, 0); 512018334Speter return inside_init; 512118334Speter } 512218334Speter 512318334Speter /* Handle scalar types, including conversions. */ 512418334Speter 512518334Speter if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 5126260311Spfg /* APPLE LOCAL radar 5732232 - blocks */ 5127260311Spfg || code == BLOCK_POINTER_TYPE 5128169689Skan || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 5129169689Skan || code == VECTOR_TYPE) 513018334Speter { 5131169689Skan if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 5132169689Skan && (TREE_CODE (init) == STRING_CST 5133169689Skan || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 5134169689Skan init = array_to_pointer_conversion (init); 513518334Speter inside_init 5136169689Skan = convert_for_assignment (type, init, ic_init, 513718334Speter NULL_TREE, NULL_TREE, 0); 513818334Speter 5139169689Skan /* Check to see if we have already given an error message. */ 5140169689Skan if (inside_init == error_mark_node) 5141169689Skan ; 5142169689Skan else if (require_constant && !TREE_CONSTANT (inside_init)) 514318334Speter { 514452284Sobrien error_init ("initializer element is not constant"); 514518334Speter inside_init = error_mark_node; 514618334Speter } 514718334Speter else if (require_constant 5148169689Skan && !initializer_constant_valid_p (inside_init, 5149169689Skan TREE_TYPE (inside_init))) 515018334Speter { 515152284Sobrien error_init ("initializer element is not computable at load time"); 515218334Speter inside_init = error_mark_node; 515318334Speter } 515418334Speter 515518334Speter return inside_init; 515618334Speter } 515718334Speter 515818334Speter /* Come here only for records and arrays. */ 515918334Speter 516090075Sobrien if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 516118334Speter { 516252284Sobrien error_init ("variable-sized object may not be initialized"); 516318334Speter return error_mark_node; 516418334Speter } 516518334Speter 516652284Sobrien error_init ("invalid initializer"); 516718334Speter return error_mark_node; 516818334Speter} 516918334Speter 517018334Speter/* Handle initializers that use braces. */ 517118334Speter 517218334Speter/* Type of object we are accumulating a constructor for. 517318334Speter This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 517418334Speterstatic tree constructor_type; 517518334Speter 517618334Speter/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 517718334Speter left to fill. */ 517818334Speterstatic tree constructor_fields; 517918334Speter 518018334Speter/* For an ARRAY_TYPE, this is the specified index 518190075Sobrien at which to store the next element we get. */ 518218334Speterstatic tree constructor_index; 518318334Speter 518418334Speter/* For an ARRAY_TYPE, this is the maximum index. */ 518518334Speterstatic tree constructor_max_index; 518618334Speter 518718334Speter/* For a RECORD_TYPE, this is the first field not yet written out. */ 518818334Speterstatic tree constructor_unfilled_fields; 518918334Speter 519018334Speter/* For an ARRAY_TYPE, this is the index of the first element 519190075Sobrien not yet written out. */ 519218334Speterstatic tree constructor_unfilled_index; 519318334Speter 519418334Speter/* In a RECORD_TYPE, the byte index of the next consecutive field. 519590075Sobrien This is so we can generate gaps between fields, when appropriate. */ 519618334Speterstatic tree constructor_bit_index; 519718334Speter 519818334Speter/* If we are saving up the elements rather than allocating them, 519918334Speter this is the list of elements so far (in reverse order, 520018334Speter most recent first). */ 5201169689Skanstatic VEC(constructor_elt,gc) *constructor_elements; 520218334Speter 520390075Sobrien/* 1 if constructor should be incrementally stored into a constructor chain, 520490075Sobrien 0 if all the elements should be kept in AVL tree. */ 520590075Sobrienstatic int constructor_incremental; 520690075Sobrien 520718334Speter/* 1 if so far this constructor's elements are all compile-time constants. */ 520818334Speterstatic int constructor_constant; 520918334Speter 521018334Speter/* 1 if so far this constructor's elements are all valid address constants. */ 521118334Speterstatic int constructor_simple; 521218334Speter 521318334Speter/* 1 if this constructor is erroneous so far. */ 521418334Speterstatic int constructor_erroneous; 521518334Speter 521650397Sobrien/* Structure for managing pending initializer elements, organized as an 521750397Sobrien AVL tree. */ 521850397Sobrien 521950397Sobrienstruct init_node 522050397Sobrien{ 522150397Sobrien struct init_node *left, *right; 522250397Sobrien struct init_node *parent; 522350397Sobrien int balance; 522450397Sobrien tree purpose; 522550397Sobrien tree value; 522650397Sobrien}; 522750397Sobrien 522850397Sobrien/* Tree of pending elements at this constructor level. 522918334Speter These are elements encountered out of order 523018334Speter which belong at places we haven't reached yet in actually 523190075Sobrien writing the output. 523290075Sobrien Will never hold tree nodes across GC runs. */ 523350397Sobrienstatic struct init_node *constructor_pending_elts; 523418334Speter 523518334Speter/* The SPELLING_DEPTH of this constructor. */ 523618334Speterstatic int constructor_depth; 523718334Speter 523818334Speter/* DECL node for which an initializer is being read. 523918334Speter 0 means we are reading a constructor expression 524018334Speter such as (struct foo) {...}. */ 524118334Speterstatic tree constructor_decl; 524218334Speter 524318334Speter/* Nonzero if this is an initializer for a top-level decl. */ 524418334Speterstatic int constructor_top_level; 524518334Speter 524690075Sobrien/* Nonzero if there were any member designators in this initializer. */ 524790075Sobrienstatic int constructor_designated; 524890075Sobrien 524990075Sobrien/* Nesting depth of designator list. */ 525090075Sobrienstatic int designator_depth; 525190075Sobrien 525290075Sobrien/* Nonzero if there were diagnosed errors in this designator list. */ 5253169689Skanstatic int designator_erroneous; 525490075Sobrien 525518334Speter 525618334Speter/* This stack has a level for each implicit or explicit level of 525718334Speter structuring in the initializer, including the outermost one. It 525818334Speter saves the values of most of the variables above. */ 525918334Speter 526090075Sobrienstruct constructor_range_stack; 526190075Sobrien 526218334Speterstruct constructor_stack 526318334Speter{ 526418334Speter struct constructor_stack *next; 526518334Speter tree type; 526618334Speter tree fields; 526718334Speter tree index; 526818334Speter tree max_index; 526918334Speter tree unfilled_index; 527018334Speter tree unfilled_fields; 527118334Speter tree bit_index; 5272169689Skan VEC(constructor_elt,gc) *elements; 527390075Sobrien struct init_node *pending_elts; 527418334Speter int offset; 527518334Speter int depth; 5276169689Skan /* If value nonzero, this value should replace the entire 527718334Speter constructor at this level. */ 5278169689Skan struct c_expr replacement_value; 527990075Sobrien struct constructor_range_stack *range_stack; 528018334Speter char constant; 528118334Speter char simple; 528218334Speter char implicit; 528318334Speter char erroneous; 528418334Speter char outer; 528590075Sobrien char incremental; 528690075Sobrien char designated; 528718334Speter}; 528818334Speter 5289169689Skanstatic struct constructor_stack *constructor_stack; 529018334Speter 529190075Sobrien/* This stack represents designators from some range designator up to 529290075Sobrien the last designator in the list. */ 529390075Sobrien 529490075Sobrienstruct constructor_range_stack 529590075Sobrien{ 529690075Sobrien struct constructor_range_stack *next, *prev; 529790075Sobrien struct constructor_stack *stack; 529890075Sobrien tree range_start; 529990075Sobrien tree index; 530090075Sobrien tree range_end; 530190075Sobrien tree fields; 530290075Sobrien}; 530390075Sobrien 5304169689Skanstatic struct constructor_range_stack *constructor_range_stack; 530590075Sobrien 530618334Speter/* This stack records separate initializers that are nested. 530718334Speter Nested initializers can't happen in ANSI C, but GNU C allows them 530818334Speter in cases like { ... (struct foo) { ... } ... }. */ 530918334Speter 531018334Speterstruct initializer_stack 531118334Speter{ 531218334Speter struct initializer_stack *next; 531318334Speter tree decl; 531418334Speter struct constructor_stack *constructor_stack; 531590075Sobrien struct constructor_range_stack *constructor_range_stack; 5316169689Skan VEC(constructor_elt,gc) *elements; 531718334Speter struct spelling *spelling; 531818334Speter struct spelling *spelling_base; 531918334Speter int spelling_size; 532018334Speter char top_level; 532118334Speter char require_constant_value; 532218334Speter char require_constant_elements; 532318334Speter}; 532418334Speter 5325169689Skanstatic struct initializer_stack *initializer_stack; 532618334Speter 532718334Speter/* Prepare to parse and output the initializer for variable DECL. */ 532818334Speter 532918334Spetervoid 5330169689Skanstart_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 533118334Speter{ 533252284Sobrien const char *locus; 5333169689Skan struct initializer_stack *p = XNEW (struct initializer_stack); 533418334Speter 533518334Speter p->decl = constructor_decl; 533618334Speter p->require_constant_value = require_constant_value; 533718334Speter p->require_constant_elements = require_constant_elements; 533818334Speter p->constructor_stack = constructor_stack; 533990075Sobrien p->constructor_range_stack = constructor_range_stack; 534018334Speter p->elements = constructor_elements; 534118334Speter p->spelling = spelling; 534218334Speter p->spelling_base = spelling_base; 534318334Speter p->spelling_size = spelling_size; 534418334Speter p->top_level = constructor_top_level; 534518334Speter p->next = initializer_stack; 534618334Speter initializer_stack = p; 534718334Speter 534818334Speter constructor_decl = decl; 534990075Sobrien constructor_designated = 0; 535018334Speter constructor_top_level = top_level; 535118334Speter 5352169689Skan if (decl != 0 && decl != error_mark_node) 535318334Speter { 535418334Speter require_constant_value = TREE_STATIC (decl); 535518334Speter require_constant_elements 535690075Sobrien = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 535718334Speter /* For a scalar, you can always use any value to initialize, 535818334Speter even within braces. */ 535918334Speter && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 536018334Speter || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 536118334Speter || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 536218334Speter || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 536318334Speter locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 536418334Speter } 536518334Speter else 536618334Speter { 536718334Speter require_constant_value = 0; 536818334Speter require_constant_elements = 0; 536918334Speter locus = "(anonymous)"; 537018334Speter } 537118334Speter 537218334Speter constructor_stack = 0; 537390075Sobrien constructor_range_stack = 0; 537418334Speter 537518334Speter missing_braces_mentioned = 0; 537618334Speter 537718334Speter spelling_base = 0; 537818334Speter spelling_size = 0; 537918334Speter RESTORE_SPELLING_DEPTH (0); 538018334Speter 538118334Speter if (locus) 538218334Speter push_string (locus); 538318334Speter} 538418334Speter 538518334Spetervoid 5386132718Skanfinish_init (void) 538718334Speter{ 538818334Speter struct initializer_stack *p = initializer_stack; 538918334Speter 539018334Speter /* Free the whole constructor stack of this initializer. */ 539118334Speter while (constructor_stack) 539218334Speter { 539318334Speter struct constructor_stack *q = constructor_stack; 539418334Speter constructor_stack = q->next; 539518334Speter free (q); 539618334Speter } 539718334Speter 5398169689Skan gcc_assert (!constructor_range_stack); 539990075Sobrien 540018334Speter /* Pop back to the data of the outer initializer (if any). */ 5401132718Skan free (spelling_base); 5402132718Skan 540318334Speter constructor_decl = p->decl; 540418334Speter require_constant_value = p->require_constant_value; 540518334Speter require_constant_elements = p->require_constant_elements; 540618334Speter constructor_stack = p->constructor_stack; 540790075Sobrien constructor_range_stack = p->constructor_range_stack; 540818334Speter constructor_elements = p->elements; 540918334Speter spelling = p->spelling; 541018334Speter spelling_base = p->spelling_base; 541118334Speter spelling_size = p->spelling_size; 541218334Speter constructor_top_level = p->top_level; 541318334Speter initializer_stack = p->next; 541418334Speter free (p); 541518334Speter} 541618334Speter 541718334Speter/* Call here when we see the initializer is surrounded by braces. 541818334Speter This is instead of a call to push_init_level; 541918334Speter it is matched by a call to pop_init_level. 542018334Speter 542118334Speter TYPE is the type to initialize, for a constructor expression. 542218334Speter For an initializer for a decl, TYPE is zero. */ 542318334Speter 542418334Spetervoid 5425132718Skanreally_start_incremental_init (tree type) 542618334Speter{ 5427169689Skan struct constructor_stack *p = XNEW (struct constructor_stack); 542818334Speter 542918334Speter if (type == 0) 543018334Speter type = TREE_TYPE (constructor_decl); 543118334Speter 5432169689Skan if (targetm.vector_opaque_p (type)) 5433132718Skan error ("opaque vector types cannot be initialized"); 5434132718Skan 543518334Speter p->type = constructor_type; 543618334Speter p->fields = constructor_fields; 543718334Speter p->index = constructor_index; 543818334Speter p->max_index = constructor_max_index; 543918334Speter p->unfilled_index = constructor_unfilled_index; 544018334Speter p->unfilled_fields = constructor_unfilled_fields; 544118334Speter p->bit_index = constructor_bit_index; 544218334Speter p->elements = constructor_elements; 544318334Speter p->constant = constructor_constant; 544418334Speter p->simple = constructor_simple; 544518334Speter p->erroneous = constructor_erroneous; 544618334Speter p->pending_elts = constructor_pending_elts; 544718334Speter p->depth = constructor_depth; 5448169689Skan p->replacement_value.value = 0; 5449169689Skan p->replacement_value.original_code = ERROR_MARK; 545018334Speter p->implicit = 0; 545190075Sobrien p->range_stack = 0; 545290075Sobrien p->outer = 0; 545318334Speter p->incremental = constructor_incremental; 545490075Sobrien p->designated = constructor_designated; 545518334Speter p->next = 0; 545618334Speter constructor_stack = p; 545718334Speter 545818334Speter constructor_constant = 1; 545918334Speter constructor_simple = 1; 546018334Speter constructor_depth = SPELLING_DEPTH (); 546118334Speter constructor_elements = 0; 546218334Speter constructor_pending_elts = 0; 546318334Speter constructor_type = type; 546490075Sobrien constructor_incremental = 1; 546590075Sobrien constructor_designated = 0; 546690075Sobrien designator_depth = 0; 5467169689Skan designator_erroneous = 0; 546818334Speter 546918334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 547018334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 547118334Speter { 547218334Speter constructor_fields = TYPE_FIELDS (constructor_type); 547318334Speter /* Skip any nameless bit fields at the beginning. */ 547450397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 547518334Speter && DECL_NAME (constructor_fields) == 0) 547618334Speter constructor_fields = TREE_CHAIN (constructor_fields); 547790075Sobrien 547818334Speter constructor_unfilled_fields = constructor_fields; 547990075Sobrien constructor_bit_index = bitsize_zero_node; 548018334Speter } 548118334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 548218334Speter { 548318334Speter if (TYPE_DOMAIN (constructor_type)) 548418334Speter { 548518334Speter constructor_max_index 548618334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 548790075Sobrien 548890075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 548990075Sobrien if (constructor_max_index == NULL_TREE 549090075Sobrien && TYPE_SIZE (constructor_type)) 5491169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 549290075Sobrien 549390075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5494117395Skan to initialize VLAs will cause a proper error; avoid tree 549590075Sobrien checking errors as well by setting a safe value. */ 549690075Sobrien if (constructor_max_index 549790075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5498169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 549990075Sobrien 550018334Speter constructor_index 550190075Sobrien = convert (bitsizetype, 550290075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 550318334Speter } 550418334Speter else 5505169689Skan { 5506169689Skan constructor_index = bitsize_zero_node; 5507169689Skan constructor_max_index = NULL_TREE; 5508169689Skan } 550990075Sobrien 551090075Sobrien constructor_unfilled_index = constructor_index; 551118334Speter } 551296263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 551396263Sobrien { 551496263Sobrien /* Vectors are like simple fixed-size arrays. */ 551596263Sobrien constructor_max_index = 5516169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5517169689Skan constructor_index = bitsize_zero_node; 551896263Sobrien constructor_unfilled_index = constructor_index; 551996263Sobrien } 552018334Speter else 552118334Speter { 552218334Speter /* Handle the case of int x = {5}; */ 552318334Speter constructor_fields = constructor_type; 552418334Speter constructor_unfilled_fields = constructor_type; 552518334Speter } 552618334Speter} 552718334Speter 552818334Speter/* Push down into a subobject, for initialization. 552918334Speter If this is for an explicit set of braces, IMPLICIT is 0. 553018334Speter If it is because the next element belongs at a lower level, 553190075Sobrien IMPLICIT is 1 (or 2 if the push is because of designator list). */ 553218334Speter 553318334Spetervoid 5534132718Skanpush_init_level (int implicit) 553518334Speter{ 553618334Speter struct constructor_stack *p; 553790075Sobrien tree value = NULL_TREE; 553818334Speter 553918334Speter /* If we've exhausted any levels that didn't have braces, 5540161651Skan pop them now. If implicit == 1, this will have been done in 5541161651Skan process_init_element; do not repeat it here because in the case 5542161651Skan of excess initializers for an empty aggregate this leads to an 5543161651Skan infinite cycle of popping a level and immediately recreating 5544161651Skan it. */ 5545161651Skan if (implicit != 1) 554618334Speter { 5547161651Skan while (constructor_stack->implicit) 5548161651Skan { 5549161651Skan if ((TREE_CODE (constructor_type) == RECORD_TYPE 5550161651Skan || TREE_CODE (constructor_type) == UNION_TYPE) 5551161651Skan && constructor_fields == 0) 5552161651Skan process_init_element (pop_init_level (1)); 5553161651Skan else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5554161651Skan && constructor_max_index 5555161651Skan && tree_int_cst_lt (constructor_max_index, 5556161651Skan constructor_index)) 5557161651Skan process_init_element (pop_init_level (1)); 5558161651Skan else 5559161651Skan break; 5560161651Skan } 556118334Speter } 556218334Speter 556390075Sobrien /* Unless this is an explicit brace, we need to preserve previous 556490075Sobrien content if any. */ 556590075Sobrien if (implicit) 556618334Speter { 556790075Sobrien if ((TREE_CODE (constructor_type) == RECORD_TYPE 556890075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 556990075Sobrien && constructor_fields) 557090075Sobrien value = find_init_member (constructor_fields); 557190075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 557290075Sobrien value = find_init_member (constructor_index); 557318334Speter } 557418334Speter 5575169689Skan p = XNEW (struct constructor_stack); 557618334Speter p->type = constructor_type; 557718334Speter p->fields = constructor_fields; 557818334Speter p->index = constructor_index; 557918334Speter p->max_index = constructor_max_index; 558018334Speter p->unfilled_index = constructor_unfilled_index; 558118334Speter p->unfilled_fields = constructor_unfilled_fields; 558218334Speter p->bit_index = constructor_bit_index; 558318334Speter p->elements = constructor_elements; 558418334Speter p->constant = constructor_constant; 558518334Speter p->simple = constructor_simple; 558618334Speter p->erroneous = constructor_erroneous; 558718334Speter p->pending_elts = constructor_pending_elts; 558818334Speter p->depth = constructor_depth; 5589169689Skan p->replacement_value.value = 0; 5590169689Skan p->replacement_value.original_code = ERROR_MARK; 559118334Speter p->implicit = implicit; 559290075Sobrien p->outer = 0; 559318334Speter p->incremental = constructor_incremental; 559490075Sobrien p->designated = constructor_designated; 559518334Speter p->next = constructor_stack; 559690075Sobrien p->range_stack = 0; 559718334Speter constructor_stack = p; 559818334Speter 559918334Speter constructor_constant = 1; 560018334Speter constructor_simple = 1; 560118334Speter constructor_depth = SPELLING_DEPTH (); 560218334Speter constructor_elements = 0; 560390075Sobrien constructor_incremental = 1; 560490075Sobrien constructor_designated = 0; 560518334Speter constructor_pending_elts = 0; 560690075Sobrien if (!implicit) 560790075Sobrien { 560890075Sobrien p->range_stack = constructor_range_stack; 560990075Sobrien constructor_range_stack = 0; 561090075Sobrien designator_depth = 0; 5611169689Skan designator_erroneous = 0; 561290075Sobrien } 561318334Speter 561418334Speter /* Don't die if an entire brace-pair level is superfluous 561518334Speter in the containing level. */ 561618334Speter if (constructor_type == 0) 561718334Speter ; 561818334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 561918334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 562018334Speter { 562118334Speter /* Don't die if there are extra init elts at the end. */ 562218334Speter if (constructor_fields == 0) 562318334Speter constructor_type = 0; 562418334Speter else 562518334Speter { 562618334Speter constructor_type = TREE_TYPE (constructor_fields); 562718334Speter push_member_name (constructor_fields); 562818334Speter constructor_depth++; 562918334Speter } 563018334Speter } 563118334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 563218334Speter { 563318334Speter constructor_type = TREE_TYPE (constructor_type); 5634169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 563518334Speter constructor_depth++; 563618334Speter } 563718334Speter 563818334Speter if (constructor_type == 0) 563918334Speter { 564052284Sobrien error_init ("extra brace group at end of initializer"); 564118334Speter constructor_fields = 0; 564218334Speter constructor_unfilled_fields = 0; 564318334Speter return; 564418334Speter } 564518334Speter 564690075Sobrien if (value && TREE_CODE (value) == CONSTRUCTOR) 564790075Sobrien { 564890075Sobrien constructor_constant = TREE_CONSTANT (value); 564990075Sobrien constructor_simple = TREE_STATIC (value); 5650132718Skan constructor_elements = CONSTRUCTOR_ELTS (value); 5651169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 565290075Sobrien && (TREE_CODE (constructor_type) == RECORD_TYPE 565390075Sobrien || TREE_CODE (constructor_type) == ARRAY_TYPE)) 565490075Sobrien set_nonincremental_init (); 565590075Sobrien } 565618334Speter 565790075Sobrien if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 565818334Speter { 565918334Speter missing_braces_mentioned = 1; 566052284Sobrien warning_init ("missing braces around initializer"); 566118334Speter } 566218334Speter 566318334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 566418334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 566518334Speter { 566618334Speter constructor_fields = TYPE_FIELDS (constructor_type); 566718334Speter /* Skip any nameless bit fields at the beginning. */ 566850397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 566918334Speter && DECL_NAME (constructor_fields) == 0) 567018334Speter constructor_fields = TREE_CHAIN (constructor_fields); 567190075Sobrien 567218334Speter constructor_unfilled_fields = constructor_fields; 567390075Sobrien constructor_bit_index = bitsize_zero_node; 567418334Speter } 567596263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 567696263Sobrien { 567796263Sobrien /* Vectors are like simple fixed-size arrays. */ 567896263Sobrien constructor_max_index = 5679169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 568096263Sobrien constructor_index = convert (bitsizetype, integer_zero_node); 568196263Sobrien constructor_unfilled_index = constructor_index; 568296263Sobrien } 568318334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 568418334Speter { 568518334Speter if (TYPE_DOMAIN (constructor_type)) 568618334Speter { 568718334Speter constructor_max_index 568818334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 568990075Sobrien 569090075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 569190075Sobrien if (constructor_max_index == NULL_TREE 569290075Sobrien && TYPE_SIZE (constructor_type)) 5693169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 569490075Sobrien 569590075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5696117395Skan to initialize VLAs will cause a proper error; avoid tree 569790075Sobrien checking errors as well by setting a safe value. */ 569890075Sobrien if (constructor_max_index 569990075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5700169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 570190075Sobrien 570218334Speter constructor_index 5703132718Skan = convert (bitsizetype, 570490075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 570518334Speter } 570618334Speter else 570790075Sobrien constructor_index = bitsize_zero_node; 570890075Sobrien 570990075Sobrien constructor_unfilled_index = constructor_index; 571090075Sobrien if (value && TREE_CODE (value) == STRING_CST) 571190075Sobrien { 571290075Sobrien /* We need to split the char/wchar array into individual 571390075Sobrien characters, so that we don't have to special case it 571490075Sobrien everywhere. */ 571590075Sobrien set_nonincremental_init_from_string (value); 571690075Sobrien } 571718334Speter } 571818334Speter else 571918334Speter { 5720169689Skan if (constructor_type != error_mark_node) 5721169689Skan warning_init ("braces around scalar initializer"); 572218334Speter constructor_fields = constructor_type; 572318334Speter constructor_unfilled_fields = constructor_type; 572418334Speter } 572518334Speter} 572618334Speter 5727132718Skan/* At the end of an implicit or explicit brace level, 5728169689Skan finish up that level of constructor. If a single expression 5729169689Skan with redundant braces initialized that level, return the 5730169689Skan c_expr structure for that expression. Otherwise, the original_code 5731169689Skan element is set to ERROR_MARK. 5732169689Skan If we were outputting the elements as they are read, return 0 as the value 573318334Speter from inner levels (process_init_element ignores that), 5734169689Skan but return error_mark_node as the value from the outermost level 573518334Speter (that's what we want to put in DECL_INITIAL). 5736169689Skan Otherwise, return a CONSTRUCTOR expression as the value. */ 573718334Speter 5738169689Skanstruct c_expr 5739132718Skanpop_init_level (int implicit) 574018334Speter{ 574118334Speter struct constructor_stack *p; 5742169689Skan struct c_expr ret; 5743169689Skan ret.value = 0; 5744169689Skan ret.original_code = ERROR_MARK; 574518334Speter 574618334Speter if (implicit == 0) 574718334Speter { 574818334Speter /* When we come to an explicit close brace, 574918334Speter pop any inner levels that didn't have explicit braces. */ 575018334Speter while (constructor_stack->implicit) 575118334Speter process_init_element (pop_init_level (1)); 575290075Sobrien 5753169689Skan gcc_assert (!constructor_range_stack); 575418334Speter } 575518334Speter 5756132718Skan /* Now output all pending elements. */ 5757132718Skan constructor_incremental = 1; 5758132718Skan output_pending_init_elements (1); 5759132718Skan 576018334Speter p = constructor_stack; 576118334Speter 576290075Sobrien /* Error for initializing a flexible array member, or a zero-length 576390075Sobrien array member in an inappropriate context. */ 576490075Sobrien if (constructor_type && constructor_fields 576590075Sobrien && TREE_CODE (constructor_type) == ARRAY_TYPE 576690075Sobrien && TYPE_DOMAIN (constructor_type) 5767169689Skan && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 576890075Sobrien { 576990075Sobrien /* Silently discard empty initializations. The parser will 577090075Sobrien already have pedwarned for empty brackets. */ 577190075Sobrien if (integer_zerop (constructor_unfilled_index)) 577290075Sobrien constructor_type = NULL_TREE; 5773169689Skan else 577490075Sobrien { 5775169689Skan gcc_assert (!TYPE_SIZE (constructor_type)); 5776169689Skan 577790075Sobrien if (constructor_depth > 2) 577890075Sobrien error_init ("initialization of flexible array member in a nested context"); 577990075Sobrien else if (pedantic) 578090075Sobrien pedwarn_init ("initialization of a flexible array member"); 578118334Speter 578290075Sobrien /* We have already issued an error message for the existence 578390075Sobrien of a flexible array member not at the end of the structure. 5784169689Skan Discard the initializer so that we do not die later. */ 578590075Sobrien if (TREE_CHAIN (constructor_fields) != NULL_TREE) 578690075Sobrien constructor_type = NULL_TREE; 578790075Sobrien } 578890075Sobrien } 578990075Sobrien 579050397Sobrien /* Warn when some struct elements are implicitly initialized to zero. */ 5791169689Skan if (warn_missing_field_initializers 579250397Sobrien && constructor_type 579350397Sobrien && TREE_CODE (constructor_type) == RECORD_TYPE 579450397Sobrien && constructor_unfilled_fields) 579550397Sobrien { 579690075Sobrien /* Do not warn for flexible array members or zero-length arrays. */ 579790075Sobrien while (constructor_unfilled_fields 5798169689Skan && (!DECL_SIZE (constructor_unfilled_fields) 579990075Sobrien || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 580090075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 580190075Sobrien 580290075Sobrien /* Do not warn if this level of the initializer uses member 580390075Sobrien designators; it is likely to be deliberate. */ 580490075Sobrien if (constructor_unfilled_fields && !constructor_designated) 580590075Sobrien { 580690075Sobrien push_member_name (constructor_unfilled_fields); 580790075Sobrien warning_init ("missing initializer"); 580890075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 580990075Sobrien } 581050397Sobrien } 581150397Sobrien 581218334Speter /* Pad out the end of the structure. */ 5813169689Skan if (p->replacement_value.value) 581490075Sobrien /* If this closes a superfluous brace pair, 581590075Sobrien just pass out the element between them. */ 5816169689Skan ret = p->replacement_value; 581718334Speter else if (constructor_type == 0) 581818334Speter ; 581918334Speter else if (TREE_CODE (constructor_type) != RECORD_TYPE 582018334Speter && TREE_CODE (constructor_type) != UNION_TYPE 582196263Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE 582296263Sobrien && TREE_CODE (constructor_type) != VECTOR_TYPE) 582318334Speter { 582418334Speter /* A nonincremental scalar initializer--just return 582518334Speter the element, after verifying there is just one. */ 5826169689Skan if (VEC_empty (constructor_elt,constructor_elements)) 582718334Speter { 582890075Sobrien if (!constructor_erroneous) 582990075Sobrien error_init ("empty scalar initializer"); 5830169689Skan ret.value = error_mark_node; 583118334Speter } 5832169689Skan else if (VEC_length (constructor_elt,constructor_elements) != 1) 583318334Speter { 583452284Sobrien error_init ("extra elements in scalar initializer"); 5835169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 583618334Speter } 583718334Speter else 5838169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 583918334Speter } 584090075Sobrien else 584118334Speter { 584218334Speter if (constructor_erroneous) 5843169689Skan ret.value = error_mark_node; 5844260311Spfg /* APPLE LOCAL begin radar 4188876 */ 5845260311Spfg else if (!constructor_constant 5846260311Spfg && TREE_CODE (constructor_type) == VECTOR_TYPE && constructor_decl 5847260311Spfg && (TREE_CODE (TREE_TYPE (constructor_decl)) == RECORD_TYPE 5848260311Spfg || TREE_CODE (TREE_TYPE (constructor_decl)) == UNION_TYPE)) 5849260311Spfg { 5850260311Spfg error ("Initializer is a non-const vector type"); 5851260311Spfg ret.value = error_mark_node; 5852260311Spfg } 5853260311Spfg /* APPLE LOCAL end radar 4188876 */ 585418334Speter else 585518334Speter { 5856169689Skan ret.value = build_constructor (constructor_type, 5857169689Skan constructor_elements); 585818334Speter if (constructor_constant) 5859169689Skan TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 586018334Speter if (constructor_constant && constructor_simple) 5861169689Skan TREE_STATIC (ret.value) = 1; 586218334Speter } 586318334Speter } 586418334Speter 586518334Speter constructor_type = p->type; 586618334Speter constructor_fields = p->fields; 586718334Speter constructor_index = p->index; 586818334Speter constructor_max_index = p->max_index; 586918334Speter constructor_unfilled_index = p->unfilled_index; 587018334Speter constructor_unfilled_fields = p->unfilled_fields; 587118334Speter constructor_bit_index = p->bit_index; 587218334Speter constructor_elements = p->elements; 587318334Speter constructor_constant = p->constant; 587418334Speter constructor_simple = p->simple; 587518334Speter constructor_erroneous = p->erroneous; 587690075Sobrien constructor_incremental = p->incremental; 587790075Sobrien constructor_designated = p->designated; 587818334Speter constructor_pending_elts = p->pending_elts; 587918334Speter constructor_depth = p->depth; 588090075Sobrien if (!p->implicit) 588190075Sobrien constructor_range_stack = p->range_stack; 588218334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 588318334Speter 588418334Speter constructor_stack = p->next; 588518334Speter free (p); 588618334Speter 5887169689Skan if (ret.value == 0 && constructor_stack == 0) 5888169689Skan ret.value = error_mark_node; 5889169689Skan return ret; 589018334Speter} 589118334Speter 589290075Sobrien/* Common handling for both array range and field name designators. 5893117395Skan ARRAY argument is nonzero for array ranges. Returns zero for success. */ 589490075Sobrien 589590075Sobrienstatic int 5896132718Skanset_designator (int array) 589790075Sobrien{ 589890075Sobrien tree subtype; 589990075Sobrien enum tree_code subcode; 590090075Sobrien 590190075Sobrien /* Don't die if an entire brace-pair level is superfluous 590290075Sobrien in the containing level. */ 590390075Sobrien if (constructor_type == 0) 590490075Sobrien return 1; 590590075Sobrien 5906169689Skan /* If there were errors in this designator list already, bail out 5907169689Skan silently. */ 5908169689Skan if (designator_erroneous) 590990075Sobrien return 1; 591090075Sobrien 591190075Sobrien if (!designator_depth) 591290075Sobrien { 5913169689Skan gcc_assert (!constructor_range_stack); 591490075Sobrien 591590075Sobrien /* Designator list starts at the level of closest explicit 591690075Sobrien braces. */ 591790075Sobrien while (constructor_stack->implicit) 591890075Sobrien process_init_element (pop_init_level (1)); 591990075Sobrien constructor_designated = 1; 592090075Sobrien return 0; 592190075Sobrien } 592290075Sobrien 5923169689Skan switch (TREE_CODE (constructor_type)) 592490075Sobrien { 5925169689Skan case RECORD_TYPE: 5926169689Skan case UNION_TYPE: 592790075Sobrien subtype = TREE_TYPE (constructor_fields); 592890075Sobrien if (subtype != error_mark_node) 592990075Sobrien subtype = TYPE_MAIN_VARIANT (subtype); 5930169689Skan break; 5931169689Skan case ARRAY_TYPE: 593290075Sobrien subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5933169689Skan break; 5934169689Skan default: 5935169689Skan gcc_unreachable (); 593690075Sobrien } 593790075Sobrien 593890075Sobrien subcode = TREE_CODE (subtype); 593990075Sobrien if (array && subcode != ARRAY_TYPE) 594090075Sobrien { 594190075Sobrien error_init ("array index in non-array initializer"); 594290075Sobrien return 1; 594390075Sobrien } 594490075Sobrien else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 594590075Sobrien { 594690075Sobrien error_init ("field name not in record or union initializer"); 594790075Sobrien return 1; 594890075Sobrien } 594990075Sobrien 595090075Sobrien constructor_designated = 1; 595190075Sobrien push_init_level (2); 595290075Sobrien return 0; 595390075Sobrien} 595490075Sobrien 595590075Sobrien/* If there are range designators in designator list, push a new designator 595690075Sobrien to constructor_range_stack. RANGE_END is end of such stack range or 595790075Sobrien NULL_TREE if there is no range designator at this level. */ 595890075Sobrien 595990075Sobrienstatic void 5960132718Skanpush_range_stack (tree range_end) 596190075Sobrien{ 596290075Sobrien struct constructor_range_stack *p; 596390075Sobrien 5964169689Skan p = GGC_NEW (struct constructor_range_stack); 596590075Sobrien p->prev = constructor_range_stack; 596690075Sobrien p->next = 0; 596790075Sobrien p->fields = constructor_fields; 596890075Sobrien p->range_start = constructor_index; 596990075Sobrien p->index = constructor_index; 597090075Sobrien p->stack = constructor_stack; 597190075Sobrien p->range_end = range_end; 597290075Sobrien if (constructor_range_stack) 597390075Sobrien constructor_range_stack->next = p; 597490075Sobrien constructor_range_stack = p; 597590075Sobrien} 597690075Sobrien 597718334Speter/* Within an array initializer, specify the next index to be initialized. 597818334Speter FIRST is that index. If LAST is nonzero, then initialize a range 597918334Speter of indices, running from FIRST through LAST. */ 598018334Speter 598118334Spetervoid 5982132718Skanset_init_index (tree first, tree last) 598318334Speter{ 598490075Sobrien if (set_designator (1)) 598590075Sobrien return; 598690075Sobrien 5987169689Skan designator_erroneous = 1; 598890075Sobrien 5989169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5990169689Skan || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5991169689Skan { 5992169689Skan error_init ("array index in initializer not of integer type"); 5993169689Skan return; 5994169689Skan } 599590075Sobrien 599618334Speter if (TREE_CODE (first) != INTEGER_CST) 599752284Sobrien error_init ("nonconstant array index in initializer"); 599818334Speter else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 599952284Sobrien error_init ("nonconstant array index in initializer"); 600090075Sobrien else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 600152284Sobrien error_init ("array index in non-array initializer"); 6002122180Skan else if (tree_int_cst_sgn (first) == -1) 6003122180Skan error_init ("array index in initializer exceeds array bounds"); 600490075Sobrien else if (constructor_max_index 600590075Sobrien && tree_int_cst_lt (constructor_max_index, first)) 600690075Sobrien error_init ("array index in initializer exceeds array bounds"); 600718334Speter else 600818334Speter { 600990075Sobrien constructor_index = convert (bitsizetype, first); 601018334Speter 601190075Sobrien if (last) 601218334Speter { 601390075Sobrien if (tree_int_cst_equal (first, last)) 601490075Sobrien last = 0; 601590075Sobrien else if (tree_int_cst_lt (last, first)) 601690075Sobrien { 601790075Sobrien error_init ("empty index range in initializer"); 601890075Sobrien last = 0; 601990075Sobrien } 602090075Sobrien else 602190075Sobrien { 602290075Sobrien last = convert (bitsizetype, last); 602390075Sobrien if (constructor_max_index != 0 602490075Sobrien && tree_int_cst_lt (constructor_max_index, last)) 602590075Sobrien { 602690075Sobrien error_init ("array index range in initializer exceeds array bounds"); 602790075Sobrien last = 0; 602890075Sobrien } 602990075Sobrien } 603018334Speter } 603190075Sobrien 603290075Sobrien designator_depth++; 6033169689Skan designator_erroneous = 0; 603490075Sobrien if (constructor_range_stack || last) 603590075Sobrien push_range_stack (last); 603618334Speter } 603718334Speter} 603818334Speter 603918334Speter/* Within a struct initializer, specify the next field to be initialized. */ 604018334Speter 604118334Spetervoid 6042132718Skanset_init_label (tree fieldname) 604318334Speter{ 6044300301Spfg tree anon = NULL_TREE; 604518334Speter tree tail; 604618334Speter 604790075Sobrien if (set_designator (0)) 604818334Speter return; 604918334Speter 6050169689Skan designator_erroneous = 1; 605190075Sobrien 605290075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 605390075Sobrien && TREE_CODE (constructor_type) != UNION_TYPE) 605490075Sobrien { 605590075Sobrien error_init ("field name not in record or union initializer"); 605690075Sobrien return; 605790075Sobrien } 6058132718Skan 605918334Speter for (tail = TYPE_FIELDS (constructor_type); tail; 606018334Speter tail = TREE_CHAIN (tail)) 606118334Speter { 6062300301Spfg if (DECL_NAME (tail) == NULL_TREE 6063300301Spfg && (TREE_CODE (TREE_TYPE (tail)) == RECORD_TYPE 6064300301Spfg || TREE_CODE (TREE_TYPE (tail)) == UNION_TYPE)) 6065300301Spfg { 6066300301Spfg anon = lookup_field (tail, fieldname); 6067300301Spfg if (anon) 6068300301Spfg break; 6069300301Spfg } 6070300301Spfg 607118334Speter if (DECL_NAME (tail) == fieldname) 607218334Speter break; 607318334Speter } 607418334Speter 607518334Speter if (tail == 0) 6076169689Skan error ("unknown field %qE specified in initializer", fieldname); 6077300319Spfg 6078300319Spfg while (tail) 607918334Speter { 608018334Speter constructor_fields = tail; 608190075Sobrien designator_depth++; 6082169689Skan designator_erroneous = 0; 608390075Sobrien if (constructor_range_stack) 608490075Sobrien push_range_stack (NULL_TREE); 6085300319Spfg 6086300319Spfg if (anon) 6087300319Spfg { 6088300319Spfg if (set_designator (0)) 6089300319Spfg return; 6090300319Spfg tail = TREE_VALUE(anon); 6091300319Spfg anon = TREE_CHAIN(anon); 6092300319Spfg } 6093300319Spfg else 6094300319Spfg tail = NULL_TREE; 609518334Speter } 609618334Speter} 609718334Speter 609850397Sobrien/* Add a new initializer to the tree of pending initializers. PURPOSE 6099132718Skan identifies the initializer, either array index or field in a structure. 610050397Sobrien VALUE is the value of that index or field. */ 610150397Sobrien 610250397Sobrienstatic void 6103132718Skanadd_pending_init (tree purpose, tree value) 610450397Sobrien{ 610550397Sobrien struct init_node *p, **q, *r; 610650397Sobrien 610750397Sobrien q = &constructor_pending_elts; 610850397Sobrien p = 0; 610950397Sobrien 611050397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 611150397Sobrien { 611250397Sobrien while (*q != 0) 611350397Sobrien { 611450397Sobrien p = *q; 611550397Sobrien if (tree_int_cst_lt (purpose, p->purpose)) 611650397Sobrien q = &p->left; 611790075Sobrien else if (tree_int_cst_lt (p->purpose, purpose)) 611850397Sobrien q = &p->right; 611950397Sobrien else 612090075Sobrien { 612190075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 612290075Sobrien warning_init ("initialized field with side-effects overwritten"); 6123169689Skan else if (warn_override_init) 6124169689Skan warning_init ("initialized field overwritten"); 612590075Sobrien p->value = value; 612690075Sobrien return; 612790075Sobrien } 612850397Sobrien } 612950397Sobrien } 613050397Sobrien else 613150397Sobrien { 613290075Sobrien tree bitpos; 613390075Sobrien 613490075Sobrien bitpos = bit_position (purpose); 613550397Sobrien while (*q != NULL) 613650397Sobrien { 613750397Sobrien p = *q; 613890075Sobrien if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 613950397Sobrien q = &p->left; 614060967Sobrien else if (p->purpose != purpose) 614150397Sobrien q = &p->right; 614250397Sobrien else 614390075Sobrien { 614490075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 614590075Sobrien warning_init ("initialized field with side-effects overwritten"); 6146169689Skan else if (warn_override_init) 6147169689Skan warning_init ("initialized field overwritten"); 614890075Sobrien p->value = value; 614990075Sobrien return; 615090075Sobrien } 615150397Sobrien } 615250397Sobrien } 615350397Sobrien 6154169689Skan r = GGC_NEW (struct init_node); 615550397Sobrien r->purpose = purpose; 615650397Sobrien r->value = value; 615750397Sobrien 615850397Sobrien *q = r; 615950397Sobrien r->parent = p; 616050397Sobrien r->left = 0; 616150397Sobrien r->right = 0; 616250397Sobrien r->balance = 0; 616350397Sobrien 616450397Sobrien while (p) 616550397Sobrien { 616650397Sobrien struct init_node *s; 616750397Sobrien 616850397Sobrien if (r == p->left) 616950397Sobrien { 617050397Sobrien if (p->balance == 0) 617150397Sobrien p->balance = -1; 617250397Sobrien else if (p->balance < 0) 617350397Sobrien { 617450397Sobrien if (r->balance < 0) 617550397Sobrien { 617690075Sobrien /* L rotation. */ 617750397Sobrien p->left = r->right; 617850397Sobrien if (p->left) 617950397Sobrien p->left->parent = p; 618050397Sobrien r->right = p; 618150397Sobrien 618250397Sobrien p->balance = 0; 618350397Sobrien r->balance = 0; 618450397Sobrien 618550397Sobrien s = p->parent; 618650397Sobrien p->parent = r; 618750397Sobrien r->parent = s; 618850397Sobrien if (s) 618950397Sobrien { 619050397Sobrien if (s->left == p) 619150397Sobrien s->left = r; 619250397Sobrien else 619350397Sobrien s->right = r; 619450397Sobrien } 619550397Sobrien else 619650397Sobrien constructor_pending_elts = r; 619750397Sobrien } 619850397Sobrien else 619950397Sobrien { 620090075Sobrien /* LR rotation. */ 620150397Sobrien struct init_node *t = r->right; 620250397Sobrien 620350397Sobrien r->right = t->left; 620450397Sobrien if (r->right) 620550397Sobrien r->right->parent = r; 620650397Sobrien t->left = r; 620750397Sobrien 620850397Sobrien p->left = t->right; 620950397Sobrien if (p->left) 621050397Sobrien p->left->parent = p; 621150397Sobrien t->right = p; 621250397Sobrien 621350397Sobrien p->balance = t->balance < 0; 621450397Sobrien r->balance = -(t->balance > 0); 621550397Sobrien t->balance = 0; 621650397Sobrien 621750397Sobrien s = p->parent; 621850397Sobrien p->parent = t; 621950397Sobrien r->parent = t; 622050397Sobrien t->parent = s; 622150397Sobrien if (s) 622250397Sobrien { 622350397Sobrien if (s->left == p) 622450397Sobrien s->left = t; 622550397Sobrien else 622650397Sobrien s->right = t; 622750397Sobrien } 622850397Sobrien else 622950397Sobrien constructor_pending_elts = t; 623050397Sobrien } 623150397Sobrien break; 623250397Sobrien } 623350397Sobrien else 623450397Sobrien { 623550397Sobrien /* p->balance == +1; growth of left side balances the node. */ 623650397Sobrien p->balance = 0; 623750397Sobrien break; 623850397Sobrien } 623950397Sobrien } 624050397Sobrien else /* r == p->right */ 624150397Sobrien { 624250397Sobrien if (p->balance == 0) 624350397Sobrien /* Growth propagation from right side. */ 624450397Sobrien p->balance++; 624550397Sobrien else if (p->balance > 0) 624650397Sobrien { 624750397Sobrien if (r->balance > 0) 624850397Sobrien { 624990075Sobrien /* R rotation. */ 625050397Sobrien p->right = r->left; 625150397Sobrien if (p->right) 625250397Sobrien p->right->parent = p; 625350397Sobrien r->left = p; 625450397Sobrien 625550397Sobrien p->balance = 0; 625650397Sobrien r->balance = 0; 625750397Sobrien 625850397Sobrien s = p->parent; 625950397Sobrien p->parent = r; 626050397Sobrien r->parent = s; 626150397Sobrien if (s) 626250397Sobrien { 626350397Sobrien if (s->left == p) 626450397Sobrien s->left = r; 626550397Sobrien else 626650397Sobrien s->right = r; 626750397Sobrien } 626850397Sobrien else 626950397Sobrien constructor_pending_elts = r; 627050397Sobrien } 627150397Sobrien else /* r->balance == -1 */ 627250397Sobrien { 627350397Sobrien /* RL rotation */ 627450397Sobrien struct init_node *t = r->left; 627550397Sobrien 627650397Sobrien r->left = t->right; 627750397Sobrien if (r->left) 627850397Sobrien r->left->parent = r; 627950397Sobrien t->right = r; 628050397Sobrien 628150397Sobrien p->right = t->left; 628250397Sobrien if (p->right) 628350397Sobrien p->right->parent = p; 628450397Sobrien t->left = p; 628550397Sobrien 628650397Sobrien r->balance = (t->balance < 0); 628750397Sobrien p->balance = -(t->balance > 0); 628850397Sobrien t->balance = 0; 628950397Sobrien 629050397Sobrien s = p->parent; 629150397Sobrien p->parent = t; 629250397Sobrien r->parent = t; 629350397Sobrien t->parent = s; 629450397Sobrien if (s) 629550397Sobrien { 629650397Sobrien if (s->left == p) 629750397Sobrien s->left = t; 629850397Sobrien else 629950397Sobrien s->right = t; 630050397Sobrien } 630150397Sobrien else 630250397Sobrien constructor_pending_elts = t; 630350397Sobrien } 630450397Sobrien break; 630550397Sobrien } 630650397Sobrien else 630750397Sobrien { 630890075Sobrien /* p->balance == -1; growth of right side balances the node. */ 630950397Sobrien p->balance = 0; 631050397Sobrien break; 631150397Sobrien } 631250397Sobrien } 631350397Sobrien 631450397Sobrien r = p; 631550397Sobrien p = p->parent; 631650397Sobrien } 631750397Sobrien} 631850397Sobrien 631990075Sobrien/* Build AVL tree from a sorted chain. */ 632050397Sobrien 632190075Sobrienstatic void 6322132718Skanset_nonincremental_init (void) 632390075Sobrien{ 6324169689Skan unsigned HOST_WIDE_INT ix; 6325169689Skan tree index, value; 632690075Sobrien 632790075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 632890075Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE) 632990075Sobrien return; 633090075Sobrien 6331169689Skan FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 6332169689Skan add_pending_init (index, value); 633390075Sobrien constructor_elements = 0; 633490075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE) 633590075Sobrien { 633690075Sobrien constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 633790075Sobrien /* Skip any nameless bit fields at the beginning. */ 633890075Sobrien while (constructor_unfilled_fields != 0 633990075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 634090075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 634190075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 6342132718Skan 634390075Sobrien } 634490075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 634590075Sobrien { 634690075Sobrien if (TYPE_DOMAIN (constructor_type)) 634790075Sobrien constructor_unfilled_index 634890075Sobrien = convert (bitsizetype, 634990075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 635090075Sobrien else 635190075Sobrien constructor_unfilled_index = bitsize_zero_node; 635290075Sobrien } 635390075Sobrien constructor_incremental = 0; 635490075Sobrien} 635590075Sobrien 635690075Sobrien/* Build AVL tree from a string constant. */ 635790075Sobrien 635890075Sobrienstatic void 6359132718Skanset_nonincremental_init_from_string (tree str) 636090075Sobrien{ 636190075Sobrien tree value, purpose, type; 636290075Sobrien HOST_WIDE_INT val[2]; 636390075Sobrien const char *p, *end; 636490075Sobrien int byte, wchar_bytes, charwidth, bitpos; 636590075Sobrien 6366169689Skan gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 636790075Sobrien 636890075Sobrien if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 636990075Sobrien == TYPE_PRECISION (char_type_node)) 637090075Sobrien wchar_bytes = 1; 637190075Sobrien else 6372169689Skan { 6373169689Skan gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6374169689Skan == TYPE_PRECISION (wchar_type_node)); 6375169689Skan wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6376169689Skan } 637790075Sobrien charwidth = TYPE_PRECISION (char_type_node); 637890075Sobrien type = TREE_TYPE (constructor_type); 637990075Sobrien p = TREE_STRING_POINTER (str); 638090075Sobrien end = p + TREE_STRING_LENGTH (str); 638190075Sobrien 638290075Sobrien for (purpose = bitsize_zero_node; 638390075Sobrien p < end && !tree_int_cst_lt (constructor_max_index, purpose); 638490075Sobrien purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 638590075Sobrien { 638690075Sobrien if (wchar_bytes == 1) 638790075Sobrien { 638890075Sobrien val[1] = (unsigned char) *p++; 638990075Sobrien val[0] = 0; 639090075Sobrien } 639190075Sobrien else 639290075Sobrien { 639390075Sobrien val[0] = 0; 639490075Sobrien val[1] = 0; 639590075Sobrien for (byte = 0; byte < wchar_bytes; byte++) 639690075Sobrien { 639790075Sobrien if (BYTES_BIG_ENDIAN) 639890075Sobrien bitpos = (wchar_bytes - byte - 1) * charwidth; 639990075Sobrien else 640090075Sobrien bitpos = byte * charwidth; 640190075Sobrien val[bitpos < HOST_BITS_PER_WIDE_INT] 640290075Sobrien |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 640390075Sobrien << (bitpos % HOST_BITS_PER_WIDE_INT); 640490075Sobrien } 640590075Sobrien } 640690075Sobrien 6407169689Skan if (!TYPE_UNSIGNED (type)) 640890075Sobrien { 640990075Sobrien bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 641090075Sobrien if (bitpos < HOST_BITS_PER_WIDE_INT) 641190075Sobrien { 641290075Sobrien if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 641390075Sobrien { 641490075Sobrien val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 641590075Sobrien val[0] = -1; 641690075Sobrien } 641790075Sobrien } 641890075Sobrien else if (bitpos == HOST_BITS_PER_WIDE_INT) 641990075Sobrien { 642090075Sobrien if (val[1] < 0) 6421169689Skan val[0] = -1; 642290075Sobrien } 642390075Sobrien else if (val[0] & (((HOST_WIDE_INT) 1) 642490075Sobrien << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 642590075Sobrien val[0] |= ((HOST_WIDE_INT) -1) 642690075Sobrien << (bitpos - HOST_BITS_PER_WIDE_INT); 642790075Sobrien } 642890075Sobrien 6429169689Skan value = build_int_cst_wide (type, val[1], val[0]); 643090075Sobrien add_pending_init (purpose, value); 643190075Sobrien } 643290075Sobrien 643390075Sobrien constructor_incremental = 0; 643490075Sobrien} 643590075Sobrien 643690075Sobrien/* Return value of FIELD in pending initializer or zero if the field was 643790075Sobrien not initialized yet. */ 643890075Sobrien 643990075Sobrienstatic tree 6440132718Skanfind_init_member (tree field) 644150397Sobrien{ 644250397Sobrien struct init_node *p; 644350397Sobrien 644450397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 644550397Sobrien { 644690075Sobrien if (constructor_incremental 644790075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 644890075Sobrien set_nonincremental_init (); 644990075Sobrien 645090075Sobrien p = constructor_pending_elts; 645150397Sobrien while (p) 645250397Sobrien { 645390075Sobrien if (tree_int_cst_lt (field, p->purpose)) 645450397Sobrien p = p->left; 645590075Sobrien else if (tree_int_cst_lt (p->purpose, field)) 645690075Sobrien p = p->right; 645750397Sobrien else 645890075Sobrien return p->value; 645950397Sobrien } 646050397Sobrien } 646190075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 646250397Sobrien { 646390075Sobrien tree bitpos = bit_position (field); 646490075Sobrien 646590075Sobrien if (constructor_incremental 646690075Sobrien && (!constructor_unfilled_fields 646790075Sobrien || tree_int_cst_lt (bitpos, 646890075Sobrien bit_position (constructor_unfilled_fields)))) 646990075Sobrien set_nonincremental_init (); 647090075Sobrien 647190075Sobrien p = constructor_pending_elts; 647250397Sobrien while (p) 647350397Sobrien { 647450397Sobrien if (field == p->purpose) 647590075Sobrien return p->value; 647690075Sobrien else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 647750397Sobrien p = p->left; 647850397Sobrien else 647950397Sobrien p = p->right; 648050397Sobrien } 648150397Sobrien } 648290075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 648390075Sobrien { 6484169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 6485169689Skan && (VEC_last (constructor_elt, constructor_elements)->index 6486169689Skan == field)) 6487169689Skan return VEC_last (constructor_elt, constructor_elements)->value; 648890075Sobrien } 648950397Sobrien return 0; 649050397Sobrien} 649150397Sobrien 649218334Speter/* "Output" the next constructor element. 649318334Speter At top level, really output it to assembler code now. 649418334Speter Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 649518334Speter TYPE is the data type that the containing data type wants here. 649618334Speter FIELD is the field (a FIELD_DECL) or the index that this element fills. 6497169689Skan If VALUE is a string constant, STRICT_STRING is true if it is 6498169689Skan unparenthesized or we should not warn here for it being parenthesized. 6499169689Skan For other types of VALUE, STRICT_STRING is not used. 650018334Speter 650118334Speter PENDING if non-nil means output pending elements that belong 650218334Speter right after this element. (PENDING is normally 1; 650318334Speter it is 0 while outputting pending elements, to avoid recursion.) */ 650418334Speter 650518334Speterstatic void 6506169689Skanoutput_init_element (tree value, bool strict_string, tree type, tree field, 6507169689Skan int pending) 650818334Speter{ 6509169689Skan constructor_elt *celt; 6510169689Skan 6511169689Skan if (type == error_mark_node || value == error_mark_node) 6512132718Skan { 6513132718Skan constructor_erroneous = 1; 6514132718Skan return; 6515132718Skan } 6516169689Skan if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6517169689Skan && (TREE_CODE (value) == STRING_CST 6518169689Skan || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6519169689Skan && !(TREE_CODE (value) == STRING_CST 6520169689Skan && TREE_CODE (type) == ARRAY_TYPE 6521169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6522169689Skan && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6523169689Skan TYPE_MAIN_VARIANT (type))) 6524169689Skan value = array_to_pointer_conversion (value); 652518334Speter 652690075Sobrien if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 652790075Sobrien && require_constant_value && !flag_isoc99 && pending) 652890075Sobrien { 652990075Sobrien /* As an extension, allow initializing objects with static storage 653090075Sobrien duration with compound literals (which are then treated just as 653190075Sobrien the brace enclosed list they contain). */ 653290075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 653390075Sobrien value = DECL_INITIAL (decl); 653490075Sobrien } 653590075Sobrien 653618334Speter if (value == error_mark_node) 653718334Speter constructor_erroneous = 1; 653818334Speter else if (!TREE_CONSTANT (value)) 653918334Speter constructor_constant = 0; 6540169689Skan else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 654118334Speter || ((TREE_CODE (constructor_type) == RECORD_TYPE 654218334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 654350397Sobrien && DECL_C_BIT_FIELD (field) 654450397Sobrien && TREE_CODE (value) != INTEGER_CST)) 654518334Speter constructor_simple = 0; 654618334Speter 6547169689Skan if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 654818334Speter { 6549169689Skan if (require_constant_value) 6550169689Skan { 6551169689Skan error_init ("initializer element is not constant"); 6552169689Skan value = error_mark_node; 6553169689Skan } 6554169689Skan else if (require_constant_elements) 6555169689Skan pedwarn ("initializer element is not computable at load time"); 655618334Speter } 655718334Speter 655890075Sobrien /* If this field is empty (and not at the end of structure), 655990075Sobrien don't do anything other than checking the initializer. */ 656090075Sobrien if (field 656190075Sobrien && (TREE_TYPE (field) == error_mark_node 656290075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (field)) 656390075Sobrien && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 656490075Sobrien && (TREE_CODE (constructor_type) == ARRAY_TYPE 656590075Sobrien || TREE_CHAIN (field))))) 656690075Sobrien return; 656790075Sobrien 6568169689Skan value = digest_init (type, value, strict_string, require_constant_value); 656990075Sobrien if (value == error_mark_node) 657018334Speter { 657190075Sobrien constructor_erroneous = 1; 657290075Sobrien return; 657318334Speter } 657418334Speter 657518334Speter /* If this element doesn't come next in sequence, 657618334Speter put it on constructor_pending_elts. */ 657718334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE 657890075Sobrien && (!constructor_incremental 657990075Sobrien || !tree_int_cst_equal (field, constructor_unfilled_index))) 658018334Speter { 658190075Sobrien if (constructor_incremental 658290075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 658390075Sobrien set_nonincremental_init (); 658490075Sobrien 658590075Sobrien add_pending_init (field, value); 658690075Sobrien return; 658718334Speter } 658818334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 658990075Sobrien && (!constructor_incremental 659090075Sobrien || field != constructor_unfilled_fields)) 659118334Speter { 659218334Speter /* We do this for records but not for unions. In a union, 659318334Speter no matter which field is specified, it can be initialized 659418334Speter right away since it starts at the beginning of the union. */ 659590075Sobrien if (constructor_incremental) 659618334Speter { 659790075Sobrien if (!constructor_unfilled_fields) 659890075Sobrien set_nonincremental_init (); 659918334Speter else 660018334Speter { 660190075Sobrien tree bitpos, unfillpos; 660218334Speter 660390075Sobrien bitpos = bit_position (field); 660490075Sobrien unfillpos = bit_position (constructor_unfilled_fields); 660518334Speter 660690075Sobrien if (tree_int_cst_lt (bitpos, unfillpos)) 660790075Sobrien set_nonincremental_init (); 660818334Speter } 660918334Speter } 661018334Speter 661190075Sobrien add_pending_init (field, value); 661290075Sobrien return; 661390075Sobrien } 661490075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE 6615169689Skan && !VEC_empty (constructor_elt, constructor_elements)) 661690075Sobrien { 6617169689Skan if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6618169689Skan constructor_elements)->value)) 661990075Sobrien warning_init ("initialized field with side-effects overwritten"); 6620169689Skan else if (warn_override_init) 6621169689Skan warning_init ("initialized field overwritten"); 662218334Speter 662390075Sobrien /* We can have just one union field set. */ 662490075Sobrien constructor_elements = 0; 662518334Speter } 662690075Sobrien 662790075Sobrien /* Otherwise, output this element either to 662890075Sobrien constructor_elements or to the assembler file. */ 662990075Sobrien 6630169689Skan celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6631169689Skan celt->index = field; 6632169689Skan celt->value = value; 663390075Sobrien 663490075Sobrien /* Advance the variable that indicates sequential elements output. */ 663590075Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 663690075Sobrien constructor_unfilled_index 663790075Sobrien = size_binop (PLUS_EXPR, constructor_unfilled_index, 663890075Sobrien bitsize_one_node); 663990075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 664090075Sobrien { 664190075Sobrien constructor_unfilled_fields 664290075Sobrien = TREE_CHAIN (constructor_unfilled_fields); 664390075Sobrien 664490075Sobrien /* Skip any nameless bit fields. */ 664590075Sobrien while (constructor_unfilled_fields != 0 664690075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 664790075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 664890075Sobrien constructor_unfilled_fields = 664990075Sobrien TREE_CHAIN (constructor_unfilled_fields); 665090075Sobrien } 665190075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 665290075Sobrien constructor_unfilled_fields = 0; 665390075Sobrien 665490075Sobrien /* Now output any pending elements which have become next. */ 665590075Sobrien if (pending) 665690075Sobrien output_pending_init_elements (0); 665718334Speter} 665818334Speter 665918334Speter/* Output any pending elements which have become next. 666018334Speter As we output elements, constructor_unfilled_{fields,index} 666118334Speter advances, which may cause other elements to become next; 666218334Speter if so, they too are output. 666318334Speter 666418334Speter If ALL is 0, we return when there are 666518334Speter no more pending elements to output now. 666618334Speter 666718334Speter If ALL is 1, we output space as necessary so that 666818334Speter we can output all the pending elements. */ 666918334Speter 667018334Speterstatic void 6671132718Skanoutput_pending_init_elements (int all) 667218334Speter{ 667350397Sobrien struct init_node *elt = constructor_pending_elts; 667418334Speter tree next; 667518334Speter 667618334Speter retry: 667718334Speter 6678132718Skan /* Look through the whole pending tree. 667918334Speter If we find an element that should be output now, 668018334Speter output it. Otherwise, set NEXT to the element 668118334Speter that comes first among those still pending. */ 6682132718Skan 668318334Speter next = 0; 668450397Sobrien while (elt) 668518334Speter { 668618334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE) 668718334Speter { 668850397Sobrien if (tree_int_cst_equal (elt->purpose, 668918334Speter constructor_unfilled_index)) 6690169689Skan output_init_element (elt->value, true, 669150397Sobrien TREE_TYPE (constructor_type), 669250397Sobrien constructor_unfilled_index, 0); 669350397Sobrien else if (tree_int_cst_lt (constructor_unfilled_index, 669450397Sobrien elt->purpose)) 669518334Speter { 669650397Sobrien /* Advance to the next smaller node. */ 669750397Sobrien if (elt->left) 669850397Sobrien elt = elt->left; 669950397Sobrien else 670050397Sobrien { 670150397Sobrien /* We have reached the smallest node bigger than the 670250397Sobrien current unfilled index. Fill the space first. */ 670350397Sobrien next = elt->purpose; 670450397Sobrien break; 670550397Sobrien } 670618334Speter } 670750397Sobrien else 670850397Sobrien { 670950397Sobrien /* Advance to the next bigger node. */ 671050397Sobrien if (elt->right) 671150397Sobrien elt = elt->right; 671250397Sobrien else 671350397Sobrien { 671450397Sobrien /* We have reached the biggest node in a subtree. Find 671550397Sobrien the parent of it, which is the next bigger node. */ 671650397Sobrien while (elt->parent && elt->parent->right == elt) 671750397Sobrien elt = elt->parent; 671850397Sobrien elt = elt->parent; 671950397Sobrien if (elt && tree_int_cst_lt (constructor_unfilled_index, 672050397Sobrien elt->purpose)) 672150397Sobrien { 672250397Sobrien next = elt->purpose; 672350397Sobrien break; 672450397Sobrien } 672550397Sobrien } 672650397Sobrien } 672718334Speter } 672818334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 672918334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 673018334Speter { 673190075Sobrien tree ctor_unfilled_bitpos, elt_bitpos; 673290075Sobrien 673350397Sobrien /* If the current record is complete we are done. */ 673450397Sobrien if (constructor_unfilled_fields == 0) 673550397Sobrien break; 673690075Sobrien 673790075Sobrien ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 673890075Sobrien elt_bitpos = bit_position (elt->purpose); 673990075Sobrien /* We can't compare fields here because there might be empty 674090075Sobrien fields in between. */ 674190075Sobrien if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 674218334Speter { 674390075Sobrien constructor_unfilled_fields = elt->purpose; 6744169689Skan output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 674590075Sobrien elt->purpose, 0); 674618334Speter } 674790075Sobrien else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 674850397Sobrien { 674950397Sobrien /* Advance to the next smaller node. */ 675050397Sobrien if (elt->left) 675150397Sobrien elt = elt->left; 675250397Sobrien else 675350397Sobrien { 675450397Sobrien /* We have reached the smallest node bigger than the 675550397Sobrien current unfilled field. Fill the space first. */ 675650397Sobrien next = elt->purpose; 675750397Sobrien break; 675850397Sobrien } 675950397Sobrien } 676050397Sobrien else 676150397Sobrien { 676250397Sobrien /* Advance to the next bigger node. */ 676350397Sobrien if (elt->right) 676450397Sobrien elt = elt->right; 676550397Sobrien else 676650397Sobrien { 676750397Sobrien /* We have reached the biggest node in a subtree. Find 676850397Sobrien the parent of it, which is the next bigger node. */ 676950397Sobrien while (elt->parent && elt->parent->right == elt) 677050397Sobrien elt = elt->parent; 677150397Sobrien elt = elt->parent; 677250397Sobrien if (elt 677390075Sobrien && (tree_int_cst_lt (ctor_unfilled_bitpos, 677490075Sobrien bit_position (elt->purpose)))) 677550397Sobrien { 677650397Sobrien next = elt->purpose; 677750397Sobrien break; 677850397Sobrien } 677950397Sobrien } 678050397Sobrien } 678118334Speter } 678218334Speter } 678318334Speter 678418334Speter /* Ordinarily return, but not if we want to output all 678518334Speter and there are elements left. */ 6786169689Skan if (!(all && next != 0)) 678718334Speter return; 678818334Speter 678990075Sobrien /* If it's not incremental, just skip over the gap, so that after 679090075Sobrien jumping to retry we will output the next successive element. */ 679190075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE 679290075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 679390075Sobrien constructor_unfilled_fields = next; 679490075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 679590075Sobrien constructor_unfilled_index = next; 679618334Speter 679750397Sobrien /* ELT now points to the node in the pending tree with the next 679850397Sobrien initializer to output. */ 679918334Speter goto retry; 680018334Speter} 680118334Speter 680218334Speter/* Add one non-braced element to the current constructor level. 680318334Speter This adjusts the current position within the constructor's type. 680418334Speter This may also start or terminate implicit levels 680518334Speter to handle a partly-braced initializer. 680618334Speter 680718334Speter Once this has found the correct level for the new element, 680890075Sobrien it calls output_init_element. */ 680918334Speter 681018334Spetervoid 6811169689Skanprocess_init_element (struct c_expr value) 681218334Speter{ 6813169689Skan tree orig_value = value.value; 6814169689Skan int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6815169689Skan bool strict_string = value.original_code == STRING_CST; 681618334Speter 681790075Sobrien designator_depth = 0; 6818169689Skan designator_erroneous = 0; 681990075Sobrien 682018334Speter /* Handle superfluous braces around string cst as in 682118334Speter char x[] = {"foo"}; */ 682218334Speter if (string_flag 682318334Speter && constructor_type 682418334Speter && TREE_CODE (constructor_type) == ARRAY_TYPE 6825169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 682618334Speter && integer_zerop (constructor_unfilled_index)) 682718334Speter { 6828169689Skan if (constructor_stack->replacement_value.value) 6829169689Skan error_init ("excess elements in char array initializer"); 683018334Speter constructor_stack->replacement_value = value; 683118334Speter return; 683218334Speter } 683318334Speter 6834169689Skan if (constructor_stack->replacement_value.value != 0) 683518334Speter { 683652284Sobrien error_init ("excess elements in struct initializer"); 683718334Speter return; 683818334Speter } 683918334Speter 684018334Speter /* Ignore elements of a brace group if it is entirely superfluous 684118334Speter and has already been diagnosed. */ 684218334Speter if (constructor_type == 0) 684318334Speter return; 684418334Speter 684518334Speter /* If we've exhausted any levels that didn't have braces, 684618334Speter pop them now. */ 684718334Speter while (constructor_stack->implicit) 684818334Speter { 684918334Speter if ((TREE_CODE (constructor_type) == RECORD_TYPE 685018334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 685118334Speter && constructor_fields == 0) 685218334Speter process_init_element (pop_init_level (1)); 685318334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE 685450397Sobrien && (constructor_max_index == 0 685550397Sobrien || tree_int_cst_lt (constructor_max_index, 685650397Sobrien constructor_index))) 685718334Speter process_init_element (pop_init_level (1)); 685818334Speter else 685918334Speter break; 686018334Speter } 686118334Speter 686290075Sobrien /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 686390075Sobrien if (constructor_range_stack) 686490075Sobrien { 686590075Sobrien /* If value is a compound literal and we'll be just using its 686690075Sobrien content, don't put it into a SAVE_EXPR. */ 6867169689Skan if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 686890075Sobrien || !require_constant_value 686990075Sobrien || flag_isoc99) 6870169689Skan value.value = save_expr (value.value); 687190075Sobrien } 687290075Sobrien 687318334Speter while (1) 687418334Speter { 687518334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE) 687618334Speter { 687718334Speter tree fieldtype; 687818334Speter enum tree_code fieldcode; 687918334Speter 688018334Speter if (constructor_fields == 0) 688118334Speter { 688252284Sobrien pedwarn_init ("excess elements in struct initializer"); 688318334Speter break; 688418334Speter } 688518334Speter 688618334Speter fieldtype = TREE_TYPE (constructor_fields); 688718334Speter if (fieldtype != error_mark_node) 688818334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 688918334Speter fieldcode = TREE_CODE (fieldtype); 689018334Speter 689196263Sobrien /* Error for non-static initialization of a flexible array member. */ 689296263Sobrien if (fieldcode == ARRAY_TYPE 689396263Sobrien && !require_constant_value 689496263Sobrien && TYPE_SIZE (fieldtype) == NULL_TREE 689596263Sobrien && TREE_CHAIN (constructor_fields) == NULL_TREE) 689696263Sobrien { 689796263Sobrien error_init ("non-static initialization of a flexible array member"); 689896263Sobrien break; 689996263Sobrien } 690096263Sobrien 690118334Speter /* Accept a string constant to initialize a subarray. */ 6902169689Skan if (value.value != 0 690318334Speter && fieldcode == ARRAY_TYPE 6904169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 690518334Speter && string_flag) 6906169689Skan value.value = orig_value; 690718334Speter /* Otherwise, if we have come to a subaggregate, 690818334Speter and we don't have an element of its type, push into it. */ 6909169689Skan else if (value.value != 0 6910169689Skan && value.value != error_mark_node 6911169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 691218334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 691318334Speter || fieldcode == UNION_TYPE)) 691418334Speter { 691518334Speter push_init_level (1); 691618334Speter continue; 691718334Speter } 691818334Speter 6919169689Skan if (value.value) 692018334Speter { 692118334Speter push_member_name (constructor_fields); 6922169689Skan output_init_element (value.value, strict_string, 6923169689Skan fieldtype, constructor_fields, 1); 692418334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 692518334Speter } 692618334Speter else 692718334Speter /* Do the bookkeeping for an element that was 692818334Speter directly output as a constructor. */ 692918334Speter { 693018334Speter /* For a record, keep track of end position of last field. */ 693190075Sobrien if (DECL_SIZE (constructor_fields)) 6932169689Skan constructor_bit_index 693390075Sobrien = size_binop (PLUS_EXPR, 6934169689Skan bit_position (constructor_fields), 6935169689Skan DECL_SIZE (constructor_fields)); 693618334Speter 6937110611Skan /* If the current field was the first one not yet written out, 6938110611Skan it isn't now, so update. */ 6939110611Skan if (constructor_unfilled_fields == constructor_fields) 6940110611Skan { 6941110611Skan constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6942110611Skan /* Skip any nameless bit fields. */ 6943110611Skan while (constructor_unfilled_fields != 0 6944110611Skan && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6945110611Skan && DECL_NAME (constructor_unfilled_fields) == 0) 6946110611Skan constructor_unfilled_fields = 6947110611Skan TREE_CHAIN (constructor_unfilled_fields); 6948110611Skan } 694918334Speter } 695018334Speter 695118334Speter constructor_fields = TREE_CHAIN (constructor_fields); 695218334Speter /* Skip any nameless bit fields at the beginning. */ 695350397Sobrien while (constructor_fields != 0 695450397Sobrien && DECL_C_BIT_FIELD (constructor_fields) 695518334Speter && DECL_NAME (constructor_fields) == 0) 695618334Speter constructor_fields = TREE_CHAIN (constructor_fields); 695718334Speter } 695890075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 695918334Speter { 696018334Speter tree fieldtype; 696118334Speter enum tree_code fieldcode; 696218334Speter 696318334Speter if (constructor_fields == 0) 696418334Speter { 696552284Sobrien pedwarn_init ("excess elements in union initializer"); 696618334Speter break; 696718334Speter } 696818334Speter 696918334Speter fieldtype = TREE_TYPE (constructor_fields); 697018334Speter if (fieldtype != error_mark_node) 697118334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 697218334Speter fieldcode = TREE_CODE (fieldtype); 697318334Speter 697490075Sobrien /* Warn that traditional C rejects initialization of unions. 697590075Sobrien We skip the warning if the value is zero. This is done 697690075Sobrien under the assumption that the zero initializer in user 697790075Sobrien code appears conditioned on e.g. __STDC__ to avoid 697890075Sobrien "missing initializer" warnings and relies on default 697990075Sobrien initialization to zero in the traditional C case. 698090075Sobrien We also skip the warning if the initializer is designated, 698190075Sobrien again on the assumption that this must be conditional on 698290075Sobrien __STDC__ anyway (and we've already complained about the 698390075Sobrien member-designator already). */ 6984169689Skan if (!in_system_header && !constructor_designated 6985169689Skan && !(value.value && (integer_zerop (value.value) 6986169689Skan || real_zerop (value.value)))) 6987169689Skan warning (OPT_Wtraditional, "traditional C rejects initialization " 6988169689Skan "of unions"); 698990075Sobrien 699018334Speter /* Accept a string constant to initialize a subarray. */ 6991169689Skan if (value.value != 0 699218334Speter && fieldcode == ARRAY_TYPE 6993169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 699418334Speter && string_flag) 6995169689Skan value.value = orig_value; 699618334Speter /* Otherwise, if we have come to a subaggregate, 699718334Speter and we don't have an element of its type, push into it. */ 6998169689Skan else if (value.value != 0 6999169689Skan && value.value != error_mark_node 7000169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 700118334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 700218334Speter || fieldcode == UNION_TYPE)) 700318334Speter { 700418334Speter push_init_level (1); 700518334Speter continue; 700618334Speter } 700718334Speter 7008169689Skan if (value.value) 700918334Speter { 701018334Speter push_member_name (constructor_fields); 7011169689Skan output_init_element (value.value, strict_string, 7012169689Skan fieldtype, constructor_fields, 1); 701318334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 701418334Speter } 701518334Speter else 701618334Speter /* Do the bookkeeping for an element that was 701718334Speter directly output as a constructor. */ 701818334Speter { 701990075Sobrien constructor_bit_index = DECL_SIZE (constructor_fields); 702018334Speter constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 702118334Speter } 702218334Speter 702318334Speter constructor_fields = 0; 702418334Speter } 702590075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 702618334Speter { 702718334Speter tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 702818334Speter enum tree_code eltcode = TREE_CODE (elttype); 702918334Speter 703018334Speter /* Accept a string constant to initialize a subarray. */ 7031169689Skan if (value.value != 0 703218334Speter && eltcode == ARRAY_TYPE 7033169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 703418334Speter && string_flag) 7035169689Skan value.value = orig_value; 703618334Speter /* Otherwise, if we have come to a subaggregate, 703718334Speter and we don't have an element of its type, push into it. */ 7038169689Skan else if (value.value != 0 7039169689Skan && value.value != error_mark_node 7040169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 704118334Speter && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 704218334Speter || eltcode == UNION_TYPE)) 704318334Speter { 704418334Speter push_init_level (1); 704518334Speter continue; 704618334Speter } 704718334Speter 704818334Speter if (constructor_max_index != 0 704990075Sobrien && (tree_int_cst_lt (constructor_max_index, constructor_index) 705090075Sobrien || integer_all_onesp (constructor_max_index))) 705118334Speter { 705252284Sobrien pedwarn_init ("excess elements in array initializer"); 705318334Speter break; 705418334Speter } 705518334Speter 705690075Sobrien /* Now output the actual element. */ 7057169689Skan if (value.value) 705850397Sobrien { 7059169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 7060169689Skan output_init_element (value.value, strict_string, 7061169689Skan elttype, constructor_index, 1); 706290075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 706350397Sobrien } 706450397Sobrien 706590075Sobrien constructor_index 706690075Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 706718334Speter 7068169689Skan if (!value.value) 706990075Sobrien /* If we are doing the bookkeeping for an element that was 707090075Sobrien directly output as a constructor, we must update 707190075Sobrien constructor_unfilled_index. */ 707290075Sobrien constructor_unfilled_index = constructor_index; 707318334Speter } 707496263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 707596263Sobrien { 707696263Sobrien tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 707718334Speter 7078169689Skan /* Do a basic check of initializer size. Note that vectors 7079169689Skan always have a fixed size derived from their type. */ 708096263Sobrien if (tree_int_cst_lt (constructor_max_index, constructor_index)) 708196263Sobrien { 708296263Sobrien pedwarn_init ("excess elements in vector initializer"); 708396263Sobrien break; 708496263Sobrien } 708596263Sobrien 708696263Sobrien /* Now output the actual element. */ 7087169689Skan if (value.value) 7088169689Skan output_init_element (value.value, strict_string, 7089169689Skan elttype, constructor_index, 1); 709096263Sobrien 709196263Sobrien constructor_index 709296263Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 709396263Sobrien 7094169689Skan if (!value.value) 709596263Sobrien /* If we are doing the bookkeeping for an element that was 709696263Sobrien directly output as a constructor, we must update 709796263Sobrien constructor_unfilled_index. */ 709896263Sobrien constructor_unfilled_index = constructor_index; 709996263Sobrien } 710096263Sobrien 710118334Speter /* Handle the sole element allowed in a braced initializer 710218334Speter for a scalar variable. */ 7103169689Skan else if (constructor_type != error_mark_node 7104169689Skan && constructor_fields == 0) 710518334Speter { 710652284Sobrien pedwarn_init ("excess elements in scalar initializer"); 710718334Speter break; 710818334Speter } 710990075Sobrien else 711090075Sobrien { 7111169689Skan if (value.value) 7112169689Skan output_init_element (value.value, strict_string, 7113169689Skan constructor_type, NULL_TREE, 1); 711490075Sobrien constructor_fields = 0; 711590075Sobrien } 711618334Speter 711790075Sobrien /* Handle range initializers either at this level or anywhere higher 711890075Sobrien in the designator stack. */ 711990075Sobrien if (constructor_range_stack) 712090075Sobrien { 712190075Sobrien struct constructor_range_stack *p, *range_stack; 712290075Sobrien int finish = 0; 712390075Sobrien 712490075Sobrien range_stack = constructor_range_stack; 712590075Sobrien constructor_range_stack = 0; 712690075Sobrien while (constructor_stack != range_stack->stack) 712790075Sobrien { 7128169689Skan gcc_assert (constructor_stack->implicit); 712990075Sobrien process_init_element (pop_init_level (1)); 713090075Sobrien } 713190075Sobrien for (p = range_stack; 713290075Sobrien !p->range_end || tree_int_cst_equal (p->index, p->range_end); 713390075Sobrien p = p->prev) 713490075Sobrien { 7135169689Skan gcc_assert (constructor_stack->implicit); 713690075Sobrien process_init_element (pop_init_level (1)); 713790075Sobrien } 713890075Sobrien 713990075Sobrien p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 714090075Sobrien if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 714190075Sobrien finish = 1; 714290075Sobrien 714390075Sobrien while (1) 714490075Sobrien { 714590075Sobrien constructor_index = p->index; 714690075Sobrien constructor_fields = p->fields; 714790075Sobrien if (finish && p->range_end && p->index == p->range_start) 714890075Sobrien { 714990075Sobrien finish = 0; 715090075Sobrien p->prev = 0; 715190075Sobrien } 715290075Sobrien p = p->next; 715390075Sobrien if (!p) 715490075Sobrien break; 715590075Sobrien push_init_level (2); 715690075Sobrien p->stack = constructor_stack; 715790075Sobrien if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 715890075Sobrien p->index = p->range_start; 715990075Sobrien } 716090075Sobrien 716190075Sobrien if (!finish) 716290075Sobrien constructor_range_stack = range_stack; 716390075Sobrien continue; 716490075Sobrien } 716590075Sobrien 716618334Speter break; 716718334Speter } 716818334Speter 716990075Sobrien constructor_range_stack = 0; 717018334Speter} 717118334Speter 7172169689Skan/* Build a complete asm-statement, whose components are a CV_QUALIFIER 7173169689Skan (guaranteed to be 'volatile' or null) and ARGS (represented using 7174169689Skan an ASM_EXPR node). */ 717590075Sobrientree 7176169689Skanbuild_asm_stmt (tree cv_qualifier, tree args) 717790075Sobrien{ 7178169689Skan if (!ASM_VOLATILE_P (args) && cv_qualifier) 7179169689Skan ASM_VOLATILE_P (args) = 1; 7180169689Skan return add_stmt (args); 718190075Sobrien} 718290075Sobrien 7183169689Skan/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 7184169689Skan some INPUTS, and some CLOBBERS. The latter three may be NULL. 7185169689Skan SIMPLE indicates whether there was anything at all after the 7186169689Skan string in the asm expression -- asm("blah") and asm("blah" : ) 7187169689Skan are subtly different. We use a ASM_EXPR node to represent this. */ 718890075Sobrientree 7189169689Skanbuild_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 7190169689Skan bool simple) 719190075Sobrien{ 719290075Sobrien tree tail; 7193169689Skan tree args; 7194169689Skan int i; 7195169689Skan const char *constraint; 7196169689Skan const char **oconstraints; 7197169689Skan bool allows_mem, allows_reg, is_inout; 7198169689Skan int ninputs, noutputs; 719990075Sobrien 7200169689Skan ninputs = list_length (inputs); 7201169689Skan noutputs = list_length (outputs); 7202169689Skan oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 720390075Sobrien 7204169689Skan string = resolve_asm_operand_names (string, outputs, inputs); 720590075Sobrien 7206169689Skan /* Remove output conversions that change the type but not the mode. */ 7207169689Skan for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 720890075Sobrien { 720990075Sobrien tree output = TREE_VALUE (tail); 721090075Sobrien 7211169689Skan /* ??? Really, this should not be here. Users should be using a 7212169689Skan proper lvalue, dammit. But there's a long history of using casts 7213169689Skan in the output operands. In cases like longlong.h, this becomes a 7214169689Skan primitive form of typechecking -- if the cast can be removed, then 7215169689Skan the output operand had a type of the proper width; otherwise we'll 7216169689Skan get an error. Gross, but ... */ 721790075Sobrien STRIP_NOPS (output); 721890075Sobrien 7219169689Skan if (!lvalue_or_else (output, lv_asm)) 7220169689Skan output = error_mark_node; 722190075Sobrien 7222169689Skan if (output != error_mark_node 7223169689Skan && (TREE_READONLY (output) 7224169689Skan || TYPE_READONLY (TREE_TYPE (output)) 7225169689Skan || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 7226169689Skan || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 7227169689Skan && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 7228169689Skan readonly_error (output, lv_asm); 7229169689Skan 7230169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 7231169689Skan oconstraints[i] = constraint; 7232169689Skan 7233169689Skan if (parse_output_constraint (&constraint, i, ninputs, noutputs, 7234169689Skan &allows_mem, &allows_reg, &is_inout)) 7235169689Skan { 7236169689Skan /* If the operand is going to end up in memory, 7237169689Skan mark it addressable. */ 7238169689Skan if (!allows_reg && !c_mark_addressable (output)) 7239169689Skan output = error_mark_node; 7240169689Skan } 7241169689Skan else 7242169689Skan output = error_mark_node; 7243169689Skan 7244169689Skan TREE_VALUE (tail) = output; 724590075Sobrien } 724690075Sobrien 7247169689Skan for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 724890075Sobrien { 7249169689Skan tree input; 7250169689Skan 7251169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 7252169689Skan input = TREE_VALUE (tail); 7253169689Skan 7254169689Skan if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 7255169689Skan oconstraints, &allows_mem, &allows_reg)) 7256169689Skan { 7257169689Skan /* If the operand is going to end up in memory, 7258169689Skan mark it addressable. */ 7259169689Skan if (!allows_reg && allows_mem) 7260169689Skan { 7261169689Skan /* Strip the nops as we allow this case. FIXME, this really 7262169689Skan should be rejected or made deprecated. */ 7263169689Skan STRIP_NOPS (input); 7264169689Skan if (!c_mark_addressable (input)) 7265169689Skan input = error_mark_node; 7266169689Skan } 7267169689Skan } 7268169689Skan else 7269169689Skan input = error_mark_node; 7270169689Skan 7271169689Skan TREE_VALUE (tail) = input; 727290075Sobrien } 727390075Sobrien 7274169689Skan args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 727590075Sobrien 7276169689Skan /* asm statements without outputs, including simple ones, are treated 7277169689Skan as volatile. */ 7278169689Skan ASM_INPUT_P (args) = simple; 7279169689Skan ASM_VOLATILE_P (args) = (noutputs == 0); 7280169689Skan 7281169689Skan return args; 728290075Sobrien} 7283169689Skan 7284169689Skan/* Generate a goto statement to LABEL. */ 728590075Sobrien 7286169689Skantree 7287169689Skanc_finish_goto_label (tree label) 728818334Speter{ 7289169689Skan tree decl = lookup_label (label); 7290169689Skan if (!decl) 7291169689Skan return NULL_TREE; 729218334Speter 7293169689Skan if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 7294117395Skan { 7295169689Skan error ("jump into statement expression"); 7296169689Skan return NULL_TREE; 7297117395Skan } 729818334Speter 7299169689Skan if (C_DECL_UNJUMPABLE_VM (decl)) 7300169689Skan { 7301169689Skan error ("jump into scope of identifier with variably modified type"); 7302169689Skan return NULL_TREE; 7303169689Skan } 730418334Speter 7305169689Skan if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 730618334Speter { 7307169689Skan /* No jump from outside this statement expression context, so 7308169689Skan record that there is a jump from within this context. */ 7309169689Skan struct c_label_list *nlist; 7310169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 7311169689Skan nlist->next = label_context_stack_se->labels_used; 7312169689Skan nlist->label = decl; 7313169689Skan label_context_stack_se->labels_used = nlist; 7314169689Skan } 731590075Sobrien 7316169689Skan if (!C_DECL_UNDEFINABLE_VM (decl)) 7317169689Skan { 7318169689Skan /* No jump from outside this context context of identifiers with 7319169689Skan variably modified type, so record that there is a jump from 7320169689Skan within this context. */ 7321169689Skan struct c_label_list *nlist; 7322169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 7323169689Skan nlist->next = label_context_stack_vm->labels_used; 7324169689Skan nlist->label = decl; 7325169689Skan label_context_stack_vm->labels_used = nlist; 732618334Speter } 732718334Speter 7328169689Skan TREE_USED (decl) = 1; 7329169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 733018334Speter} 733118334Speter 7332169689Skan/* Generate a computed goto statement to EXPR. */ 7333169689Skan 733490075Sobrientree 7335169689Skanc_finish_goto_ptr (tree expr) 733618334Speter{ 7337169689Skan if (pedantic) 7338169689Skan pedwarn ("ISO C forbids %<goto *expr;%>"); 7339169689Skan expr = convert (ptr_type_node, expr); 7340169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 7341169689Skan} 734218334Speter 7343260311Spfg/* APPLE LOCAL begin radar 5732232 - blocks (C++ cm) */ 7344260311Spfg/** c_finish_block_return_stmt - Utilty routine to figure out block's return 7345260311Spfg type. 7346260311Spfg */ 7347260311Spfgstatic tree 7348260311Spfgc_finish_block_return_stmt (tree retval) 7349260311Spfg{ 7350260311Spfg tree valtype; 7351260311Spfg /* If this is the first return we've seen in the block, infer the type of 7352260311Spfg the block from it. */ 7353260311Spfg if (cur_block->return_type == NULL_TREE) 7354260311Spfg { 7355260311Spfg tree restype; 7356260311Spfg if (retval) 7357260311Spfg { 7358260311Spfg restype = TYPE_MAIN_VARIANT (TREE_TYPE (retval)); 7359260311Spfg TREE_TYPE (current_function_decl) 7360260311Spfg = build_function_type (restype, 7361260311Spfg TYPE_ARG_TYPES (TREE_TYPE (current_function_decl))); 7362260311Spfg TREE_TYPE (DECL_RESULT (current_function_decl)) = restype; 7363260311Spfg relayout_decl (DECL_RESULT (current_function_decl)); 7364260311Spfg } 7365260311Spfg else 7366260311Spfg restype = void_type_node; 7367260311Spfg 7368260311Spfg cur_block->return_type = restype; 7369260311Spfg } 7370260311Spfg 7371260311Spfg /* Verify that this result type matches the previous one. We are 7372260311Spfg pickier with blocks than for normal functions because this is a 7373260311Spfg new feature and we set the rules. */ 7374260311Spfg if (TREE_CODE (cur_block->return_type) == VOID_TYPE) 7375260311Spfg { 7376260311Spfg if (retval) 7377260311Spfg { 7378260311Spfg error ("void block should not return a value"); 7379260311Spfg retval = NULL_TREE; 7380260311Spfg } 7381260311Spfg return retval; 7382260311Spfg } 7383260311Spfg 7384260311Spfg if (!retval) 7385260311Spfg { 7386260311Spfg error ("non-void block should return a value"); 7387260311Spfg return error_mark_node; 7388260311Spfg } 7389260311Spfg 7390260311Spfg /* We have a non-void block with an expression, continue checking. */ 7391260311Spfg valtype = TREE_TYPE (retval); 7392260311Spfg 7393260311Spfg /* For now, restrict multiple return statements in a block to have 7394260311Spfg strict compatible types only. */ 7395260311Spfg if (!types_are_block_compatible (cur_block->return_type, valtype)) 7396260311Spfg error ("incompatible type returning %qT, expected %qT", 7397260311Spfg valtype, cur_block->return_type); 7398260311Spfg return retval; 7399260311Spfg} 7400260311Spfg/* APPLE LOCAL end radar 5732232 - blocks (C++ cm) */ 7401260311Spfg 7402169689Skan/* Generate a C `return' statement. RETVAL is the expression for what 7403169689Skan to return, or a null pointer for `return;' with no value. */ 7404169689Skan 7405169689Skantree 7406169689Skanc_finish_return (tree retval) 7407169689Skan{ 7408260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks */ 7409260311Spfg tree valtype, ret_stmt; 7410169689Skan bool no_warning = false; 7411260311Spfg 7412260311Spfg /* APPLE LOCAL radar 5822844 - radar 6185344 */ 7413260311Spfg if (cur_block && !cur_block->block_has_return_type) 7414260311Spfg { 7415260311Spfg retval = c_finish_block_return_stmt (retval); 7416260311Spfg if (retval == error_mark_node) 7417260311Spfg return NULL_TREE; 7418260311Spfg } 7419260311Spfg 7420260311Spfg valtype = TREE_TYPE (TREE_TYPE (current_function_decl)); 7421260311Spfg /* APPLE LOCAL end radar 5732232 - blocks */ 7422169689Skan 742318334Speter if (TREE_THIS_VOLATILE (current_function_decl)) 7424169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 742518334Speter 742618334Speter if (!retval) 742718334Speter { 742818334Speter current_function_returns_null = 1; 742990075Sobrien if ((warn_return_type || flag_isoc99) 743090075Sobrien && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 7431169689Skan { 7432169689Skan pedwarn_c99 ("%<return%> with no value, in " 7433169689Skan "function returning non-void"); 7434169689Skan no_warning = true; 7435169689Skan } 743618334Speter } 743718334Speter else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 743818334Speter { 743918334Speter current_function_returns_null = 1; 744018334Speter if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 7441169689Skan pedwarn ("%<return%> with a value, in function returning void"); 744218334Speter } 744318334Speter else 744418334Speter { 7445169689Skan tree t = convert_for_assignment (valtype, retval, ic_return, 744618334Speter NULL_TREE, NULL_TREE, 0); 744718334Speter tree res = DECL_RESULT (current_function_decl); 744818334Speter tree inner; 744918334Speter 745096263Sobrien current_function_returns_value = 1; 745118334Speter if (t == error_mark_node) 745290075Sobrien return NULL_TREE; 745318334Speter 745418334Speter inner = t = convert (TREE_TYPE (res), t); 745518334Speter 745618334Speter /* Strip any conversions, additions, and subtractions, and see if 745718334Speter we are returning the address of a local variable. Warn if so. */ 745818334Speter while (1) 745918334Speter { 746018334Speter switch (TREE_CODE (inner)) 746118334Speter { 746218334Speter case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 746318334Speter case PLUS_EXPR: 746418334Speter inner = TREE_OPERAND (inner, 0); 746518334Speter continue; 746618334Speter 746718334Speter case MINUS_EXPR: 746818334Speter /* If the second operand of the MINUS_EXPR has a pointer 746918334Speter type (or is converted from it), this may be valid, so 747018334Speter don't give a warning. */ 747118334Speter { 747218334Speter tree op1 = TREE_OPERAND (inner, 1); 747318334Speter 7474169689Skan while (!POINTER_TYPE_P (TREE_TYPE (op1)) 747518334Speter && (TREE_CODE (op1) == NOP_EXPR 747618334Speter || TREE_CODE (op1) == NON_LVALUE_EXPR 747718334Speter || TREE_CODE (op1) == CONVERT_EXPR)) 747818334Speter op1 = TREE_OPERAND (op1, 0); 747918334Speter 748018334Speter if (POINTER_TYPE_P (TREE_TYPE (op1))) 748118334Speter break; 748218334Speter 748318334Speter inner = TREE_OPERAND (inner, 0); 748418334Speter continue; 748518334Speter } 7486132718Skan 748718334Speter case ADDR_EXPR: 748818334Speter inner = TREE_OPERAND (inner, 0); 748918334Speter 7490169689Skan while (REFERENCE_CLASS_P (inner) 7491169689Skan && TREE_CODE (inner) != INDIRECT_REF) 749218334Speter inner = TREE_OPERAND (inner, 0); 749318334Speter 7494169689Skan if (DECL_P (inner) 7495169689Skan && !DECL_EXTERNAL (inner) 7496169689Skan && !TREE_STATIC (inner) 749718334Speter && DECL_CONTEXT (inner) == current_function_decl) 7498260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks (C++ cn) */ 7499260311Spfg { 7500260311Spfg if (TREE_CODE (valtype) == BLOCK_POINTER_TYPE) 7501260311Spfg /* APPLE LOCAL radar 6048570 */ 7502260311Spfg error ("returning block that lives on the local stack"); 7503260311Spfg else 7504260311Spfg warning (0, "function returns address of local variable"); 7505260311Spfg } 7506260311Spfg /* APPLE LOCAL end radar 5732232 - blocks (C++ cn) */ 750718334Speter break; 750850397Sobrien 750950397Sobrien default: 751050397Sobrien break; 751118334Speter } 751218334Speter 751318334Speter break; 751418334Speter } 751518334Speter 7516169689Skan retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 751718334Speter } 751890075Sobrien 7519169689Skan ret_stmt = build_stmt (RETURN_EXPR, retval); 7520169689Skan TREE_NO_WARNING (ret_stmt) |= no_warning; 7521169689Skan return add_stmt (ret_stmt); 752218334Speter} 752318334Speter 752490075Sobrienstruct c_switch { 7525169689Skan /* The SWITCH_EXPR being built. */ 7526169689Skan tree switch_expr; 7527169689Skan 7528169689Skan /* The original type of the testing expression, i.e. before the 7529169689Skan default conversion is applied. */ 7530169689Skan tree orig_type; 7531169689Skan 753290075Sobrien /* A splay-tree mapping the low element of a case range to the high 753390075Sobrien element, or NULL_TREE if there is no high element. Used to 753490075Sobrien determine whether or not a new case label duplicates an old case 753590075Sobrien label. We need a tree, rather than simply a hash table, because 753690075Sobrien of the GNU case range extension. */ 753790075Sobrien splay_tree cases; 7538169689Skan 7539169689Skan /* Number of nested statement expressions within this switch 7540169689Skan statement; if nonzero, case and default labels may not 7541169689Skan appear. */ 7542169689Skan unsigned int blocked_stmt_expr; 7543169689Skan 7544169689Skan /* Scope of outermost declarations of identifiers with variably 7545169689Skan modified type within this switch statement; if nonzero, case and 7546169689Skan default labels may not appear. */ 7547169689Skan unsigned int blocked_vm; 7548169689Skan 754990075Sobrien /* The next node on the stack. */ 755090075Sobrien struct c_switch *next; 755190075Sobrien}; 755218334Speter 755390075Sobrien/* A stack of the currently active switch statements. The innermost 755490075Sobrien switch statement is on the top of the stack. There is no need to 755590075Sobrien mark the stack for garbage collection because it is only active 755690075Sobrien during the processing of the body of a function, and we never 755790075Sobrien collect at that point. */ 755890075Sobrien 7559169689Skanstruct c_switch *c_switch_stack; 756090075Sobrien 756190075Sobrien/* Start a C switch statement, testing expression EXP. Return the new 7562169689Skan SWITCH_EXPR. */ 756390075Sobrien 756418334Spetertree 7565132718Skanc_start_case (tree exp) 756618334Speter{ 7567169689Skan tree orig_type = error_mark_node; 756890075Sobrien struct c_switch *cs; 756918334Speter 757090075Sobrien if (exp != error_mark_node) 757118334Speter { 757296263Sobrien orig_type = TREE_TYPE (exp); 757390075Sobrien 7574169689Skan if (!INTEGRAL_TYPE_P (orig_type)) 757590075Sobrien { 7576169689Skan if (orig_type != error_mark_node) 7577169689Skan { 7578169689Skan error ("switch quantity not an integer"); 7579169689Skan orig_type = error_mark_node; 7580169689Skan } 758190075Sobrien exp = integer_zero_node; 758290075Sobrien } 758390075Sobrien else 758490075Sobrien { 7585169689Skan tree type = TYPE_MAIN_VARIANT (orig_type); 758690075Sobrien 7587169689Skan if (!in_system_header 758890075Sobrien && (type == long_integer_type_node 758990075Sobrien || type == long_unsigned_type_node)) 7590169689Skan warning (OPT_Wtraditional, "%<long%> switch expression not " 7591169689Skan "converted to %<int%> in ISO C"); 759290075Sobrien 759390075Sobrien exp = default_conversion (exp); 759490075Sobrien } 759518334Speter } 759618334Speter 7597169689Skan /* Add this new SWITCH_EXPR to the stack. */ 7598169689Skan cs = XNEW (struct c_switch); 7599169689Skan cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7600169689Skan cs->orig_type = orig_type; 760190075Sobrien cs->cases = splay_tree_new (case_compare, NULL, NULL); 7602169689Skan cs->blocked_stmt_expr = 0; 7603169689Skan cs->blocked_vm = 0; 7604169689Skan cs->next = c_switch_stack; 7605169689Skan c_switch_stack = cs; 760618334Speter 7607169689Skan return add_stmt (cs->switch_expr); 760890075Sobrien} 760990075Sobrien 761090075Sobrien/* Process a case label. */ 761190075Sobrien 761290075Sobrientree 7613132718Skando_case (tree low_value, tree high_value) 761490075Sobrien{ 761590075Sobrien tree label = NULL_TREE; 761690075Sobrien 7617169689Skan if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7618169689Skan && !c_switch_stack->blocked_vm) 761990075Sobrien { 7620169689Skan label = c_add_case_label (c_switch_stack->cases, 7621169689Skan SWITCH_COND (c_switch_stack->switch_expr), 7622169689Skan c_switch_stack->orig_type, 762390075Sobrien low_value, high_value); 762490075Sobrien if (label == error_mark_node) 762590075Sobrien label = NULL_TREE; 762618334Speter } 7627169689Skan else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7628169689Skan { 7629169689Skan if (low_value) 7630169689Skan error ("case label in statement expression not containing " 7631169689Skan "enclosing switch statement"); 7632169689Skan else 7633169689Skan error ("%<default%> label in statement expression not containing " 7634169689Skan "enclosing switch statement"); 7635169689Skan } 7636169689Skan else if (c_switch_stack && c_switch_stack->blocked_vm) 7637169689Skan { 7638169689Skan if (low_value) 7639169689Skan error ("case label in scope of identifier with variably modified " 7640169689Skan "type not containing enclosing switch statement"); 7641169689Skan else 7642169689Skan error ("%<default%> label in scope of identifier with variably " 7643169689Skan "modified type not containing enclosing switch statement"); 7644169689Skan } 764590075Sobrien else if (low_value) 764690075Sobrien error ("case label not within a switch statement"); 764790075Sobrien else 7648169689Skan error ("%<default%> label not within a switch statement"); 764918334Speter 765090075Sobrien return label; 765190075Sobrien} 765218334Speter 765390075Sobrien/* Finish the switch statement. */ 765490075Sobrien 765590075Sobrienvoid 7656169689Skanc_finish_case (tree body) 765790075Sobrien{ 7658169689Skan struct c_switch *cs = c_switch_stack; 7659169689Skan location_t switch_location; 766090075Sobrien 7661169689Skan SWITCH_BODY (cs->switch_expr) = body; 7662146895Skan 7663169689Skan /* We must not be within a statement expression nested in the switch 7664169689Skan at this point; we might, however, be within the scope of an 7665169689Skan identifier with variably modified type nested in the switch. */ 7666169689Skan gcc_assert (!cs->blocked_stmt_expr); 766790075Sobrien 7668169689Skan /* Emit warnings as needed. */ 7669169689Skan if (EXPR_HAS_LOCATION (cs->switch_expr)) 7670169689Skan switch_location = EXPR_LOCATION (cs->switch_expr); 7671169689Skan else 7672169689Skan switch_location = input_location; 7673169689Skan c_do_switch_warnings (cs->cases, switch_location, 7674169689Skan TREE_TYPE (cs->switch_expr), 7675169689Skan SWITCH_COND (cs->switch_expr)); 7676169689Skan 767790075Sobrien /* Pop the stack. */ 7678169689Skan c_switch_stack = cs->next; 767990075Sobrien splay_tree_delete (cs->cases); 7680169689Skan XDELETE (cs); 768118334Speter} 7682169689Skan 7683169689Skan/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7684169689Skan THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7685169689Skan may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7686169689Skan statement, and was not surrounded with parenthesis. */ 7687132718Skan 7688169689Skanvoid 7689169689Skanc_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7690169689Skan tree else_block, bool nested_if) 7691169689Skan{ 7692169689Skan tree stmt; 7693169689Skan 7694169689Skan /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7695169689Skan if (warn_parentheses && nested_if && else_block == NULL) 7696169689Skan { 7697169689Skan tree inner_if = then_block; 7698169689Skan 7699169689Skan /* We know from the grammar productions that there is an IF nested 7700169689Skan within THEN_BLOCK. Due to labels and c99 conditional declarations, 7701169689Skan it might not be exactly THEN_BLOCK, but should be the last 7702169689Skan non-container statement within. */ 7703169689Skan while (1) 7704169689Skan switch (TREE_CODE (inner_if)) 7705169689Skan { 7706169689Skan case COND_EXPR: 7707169689Skan goto found; 7708169689Skan case BIND_EXPR: 7709169689Skan inner_if = BIND_EXPR_BODY (inner_if); 7710169689Skan break; 7711169689Skan case STATEMENT_LIST: 7712169689Skan inner_if = expr_last (then_block); 7713169689Skan break; 7714169689Skan case TRY_FINALLY_EXPR: 7715169689Skan case TRY_CATCH_EXPR: 7716169689Skan inner_if = TREE_OPERAND (inner_if, 0); 7717169689Skan break; 7718169689Skan default: 7719169689Skan gcc_unreachable (); 7720169689Skan } 7721169689Skan found: 7722169689Skan 7723169689Skan if (COND_EXPR_ELSE (inner_if)) 7724169689Skan warning (OPT_Wparentheses, 7725169689Skan "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7726169689Skan &if_locus); 7727169689Skan } 7728169689Skan 7729169689Skan empty_body_warning (then_block, else_block); 7730169689Skan 7731169689Skan stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7732169689Skan SET_EXPR_LOCATION (stmt, if_locus); 7733169689Skan add_stmt (stmt); 7734169689Skan} 7735169689Skan 7736260014Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7737260014Spfg/* Emit a general-purpose loop construct. START_LOCUS is the location 7738260014Spfg of the beginning of the loop. COND is the loop condition. 7739260014Spfg COND_IS_FIRST is false for DO loops. INCR is the FOR increment 7740260014Spfg expression. BODY is the statement controlled by the loop. BLAB is 7741260014Spfg the break label. CLAB is the continue label. ATTRS is the 7742260014Spfg attributes associated with the loop, which at present are 7743260014Spfg associated with the topmost label. Everything is allowed to be 7744260014Spfg NULL. */ 7745169689Skan 7746260014Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7747169689Skanvoid 7748169689Skanc_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7749260014Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7750260014Spfg tree blab, tree clab, tree attrs, bool cond_is_first) 7751260014Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7752169689Skan{ 7753169689Skan tree entry = NULL, exit = NULL, t; 7754169689Skan 7755169689Skan /* If the condition is zero don't generate a loop construct. */ 7756169689Skan if (cond && integer_zerop (cond)) 7757169689Skan { 7758169689Skan if (cond_is_first) 7759169689Skan { 7760169689Skan t = build_and_jump (&blab); 7761169689Skan SET_EXPR_LOCATION (t, start_locus); 7762169689Skan add_stmt (t); 7763169689Skan } 7764169689Skan } 7765169689Skan else 7766169689Skan { 7767169689Skan tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7768169689Skan 7769169689Skan /* If we have an exit condition, then we build an IF with gotos either 7770169689Skan out of the loop, or to the top of it. If there's no exit condition, 7771169689Skan then we just build a jump back to the top. */ 7772169689Skan exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7773169689Skan 7774260311Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7775260311Spfg /* Add the attributes to the 'top' label. */ 7776260311Spfg decl_attributes (&LABEL_EXPR_LABEL (top), attrs, 0); 7777260311Spfg 7778260311Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7779169689Skan if (cond && !integer_nonzerop (cond)) 7780169689Skan { 7781169689Skan /* Canonicalize the loop condition to the end. This means 7782169689Skan generating a branch to the loop condition. Reuse the 7783169689Skan continue label, if possible. */ 7784169689Skan if (cond_is_first) 7785169689Skan { 7786169689Skan if (incr || !clab) 7787169689Skan { 7788169689Skan entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7789169689Skan t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7790169689Skan } 7791169689Skan else 7792169689Skan t = build1 (GOTO_EXPR, void_type_node, clab); 7793169689Skan SET_EXPR_LOCATION (t, start_locus); 7794169689Skan add_stmt (t); 7795169689Skan } 7796169689Skan 7797169689Skan t = build_and_jump (&blab); 7798169689Skan exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7799169689Skan if (cond_is_first) 7800169689Skan SET_EXPR_LOCATION (exit, start_locus); 7801169689Skan else 7802169689Skan SET_EXPR_LOCATION (exit, input_location); 7803169689Skan } 7804169689Skan 7805169689Skan add_stmt (top); 7806169689Skan } 7807169689Skan 7808169689Skan if (body) 7809169689Skan add_stmt (body); 7810169689Skan if (clab) 7811169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7812169689Skan if (incr) 7813169689Skan add_stmt (incr); 7814169689Skan if (entry) 7815169689Skan add_stmt (entry); 7816169689Skan if (exit) 7817169689Skan add_stmt (exit); 7818169689Skan if (blab) 7819169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7820169689Skan} 7821169689Skan 7822169689Skantree 7823169689Skanc_finish_bc_stmt (tree *label_p, bool is_break) 7824169689Skan{ 7825169689Skan bool skip; 7826169689Skan tree label = *label_p; 7827169689Skan 7828169689Skan /* In switch statements break is sometimes stylistically used after 7829169689Skan a return statement. This can lead to spurious warnings about 7830169689Skan control reaching the end of a non-void function when it is 7831169689Skan inlined. Note that we are calling block_may_fallthru with 7832169689Skan language specific tree nodes; this works because 7833169689Skan block_may_fallthru returns true when given something it does not 7834169689Skan understand. */ 7835169689Skan skip = !block_may_fallthru (cur_stmt_list); 7836169689Skan 7837169689Skan if (!label) 7838169689Skan { 7839169689Skan if (!skip) 7840169689Skan *label_p = label = create_artificial_label (); 7841169689Skan } 7842169689Skan else if (TREE_CODE (label) == LABEL_DECL) 7843169689Skan ; 7844169689Skan else switch (TREE_INT_CST_LOW (label)) 7845169689Skan { 7846169689Skan case 0: 7847169689Skan if (is_break) 7848169689Skan error ("break statement not within loop or switch"); 7849169689Skan else 7850169689Skan error ("continue statement not within a loop"); 7851169689Skan return NULL_TREE; 7852169689Skan 7853169689Skan case 1: 7854169689Skan gcc_assert (is_break); 7855169689Skan error ("break statement used with OpenMP for loop"); 7856169689Skan return NULL_TREE; 7857169689Skan 7858169689Skan default: 7859169689Skan gcc_unreachable (); 7860169689Skan } 7861169689Skan 7862169689Skan if (skip) 7863169689Skan return NULL_TREE; 7864169689Skan 7865169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7866169689Skan} 7867169689Skan 7868169689Skan/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7869169689Skan 7870169689Skanstatic void 7871169689Skanemit_side_effect_warnings (tree expr) 7872169689Skan{ 7873169689Skan if (expr == error_mark_node) 7874169689Skan ; 7875169689Skan else if (!TREE_SIDE_EFFECTS (expr)) 7876169689Skan { 7877169689Skan if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7878169689Skan warning (0, "%Hstatement with no effect", 7879169689Skan EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7880169689Skan } 7881169689Skan else if (warn_unused_value) 7882169689Skan warn_if_unused_value (expr, input_location); 7883169689Skan} 7884169689Skan 7885169689Skan/* Process an expression as if it were a complete statement. Emit 7886169689Skan diagnostics, but do not call ADD_STMT. */ 7887169689Skan 7888169689Skantree 7889169689Skanc_process_expr_stmt (tree expr) 7890169689Skan{ 7891169689Skan if (!expr) 7892169689Skan return NULL_TREE; 7893169689Skan 7894169689Skan if (warn_sequence_point) 7895169689Skan verify_sequence_points (expr); 7896169689Skan 7897169689Skan if (TREE_TYPE (expr) != error_mark_node 7898169689Skan && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7899169689Skan && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7900169689Skan error ("expression statement has incomplete type"); 7901169689Skan 7902169689Skan /* If we're not processing a statement expression, warn about unused values. 7903169689Skan Warnings for statement expressions will be emitted later, once we figure 7904169689Skan out which is the result. */ 7905169689Skan if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7906169689Skan && (extra_warnings || warn_unused_value)) 7907169689Skan emit_side_effect_warnings (expr); 7908169689Skan 7909169689Skan /* If the expression is not of a type to which we cannot assign a line 7910169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 7911169689Skan if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7912169689Skan expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7913169689Skan 7914169689Skan if (EXPR_P (expr)) 7915169689Skan SET_EXPR_LOCATION (expr, input_location); 7916169689Skan 7917169689Skan return expr; 7918169689Skan} 7919169689Skan 7920169689Skan/* Emit an expression as a statement. */ 7921169689Skan 7922169689Skantree 7923169689Skanc_finish_expr_stmt (tree expr) 7924169689Skan{ 7925169689Skan if (expr) 7926169689Skan return add_stmt (c_process_expr_stmt (expr)); 7927169689Skan else 7928169689Skan return NULL; 7929169689Skan} 7930169689Skan 7931169689Skan/* Do the opposite and emit a statement as an expression. To begin, 7932169689Skan create a new binding level and return it. */ 7933169689Skan 7934169689Skantree 7935169689Skanc_begin_stmt_expr (void) 7936169689Skan{ 7937169689Skan tree ret; 7938169689Skan struct c_label_context_se *nstack; 7939169689Skan struct c_label_list *glist; 7940169689Skan 7941169689Skan /* We must force a BLOCK for this level so that, if it is not expanded 7942169689Skan later, there is a way to turn off the entire subtree of blocks that 7943169689Skan are contained in it. */ 7944169689Skan keep_next_level (); 7945169689Skan ret = c_begin_compound_stmt (true); 7946169689Skan if (c_switch_stack) 7947169689Skan { 7948169689Skan c_switch_stack->blocked_stmt_expr++; 7949169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7950169689Skan } 7951169689Skan for (glist = label_context_stack_se->labels_used; 7952169689Skan glist != NULL; 7953169689Skan glist = glist->next) 7954169689Skan { 7955169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7956169689Skan } 7957169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7958169689Skan nstack->labels_def = NULL; 7959169689Skan nstack->labels_used = NULL; 7960169689Skan nstack->next = label_context_stack_se; 7961169689Skan label_context_stack_se = nstack; 7962169689Skan 7963169689Skan /* Mark the current statement list as belonging to a statement list. */ 7964169689Skan STATEMENT_LIST_STMT_EXPR (ret) = 1; 7965169689Skan 7966169689Skan return ret; 7967169689Skan} 7968169689Skan 7969169689Skantree 7970169689Skanc_finish_stmt_expr (tree body) 7971169689Skan{ 7972169689Skan tree last, type, tmp, val; 7973169689Skan tree *last_p; 7974169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7975169689Skan 7976169689Skan body = c_end_compound_stmt (body, true); 7977169689Skan if (c_switch_stack) 7978169689Skan { 7979169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7980169689Skan c_switch_stack->blocked_stmt_expr--; 7981169689Skan } 7982169689Skan /* It is no longer possible to jump to labels defined within this 7983169689Skan statement expression. */ 7984169689Skan for (dlist = label_context_stack_se->labels_def; 7985169689Skan dlist != NULL; 7986169689Skan dlist = dlist->next) 7987169689Skan { 7988169689Skan C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7989169689Skan } 7990169689Skan /* It is again possible to define labels with a goto just outside 7991169689Skan this statement expression. */ 7992169689Skan for (glist = label_context_stack_se->next->labels_used; 7993169689Skan glist != NULL; 7994169689Skan glist = glist->next) 7995169689Skan { 7996169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7997169689Skan glist_prev = glist; 7998169689Skan } 7999169689Skan if (glist_prev != NULL) 8000169689Skan glist_prev->next = label_context_stack_se->labels_used; 8001169689Skan else 8002169689Skan label_context_stack_se->next->labels_used 8003169689Skan = label_context_stack_se->labels_used; 8004169689Skan label_context_stack_se = label_context_stack_se->next; 8005169689Skan 8006169689Skan /* Locate the last statement in BODY. See c_end_compound_stmt 8007169689Skan about always returning a BIND_EXPR. */ 8008169689Skan last_p = &BIND_EXPR_BODY (body); 8009169689Skan last = BIND_EXPR_BODY (body); 8010169689Skan 8011169689Skan continue_searching: 8012169689Skan if (TREE_CODE (last) == STATEMENT_LIST) 8013169689Skan { 8014169689Skan tree_stmt_iterator i; 8015169689Skan 8016169689Skan /* This can happen with degenerate cases like ({ }). No value. */ 8017169689Skan if (!TREE_SIDE_EFFECTS (last)) 8018169689Skan return body; 8019169689Skan 8020169689Skan /* If we're supposed to generate side effects warnings, process 8021169689Skan all of the statements except the last. */ 8022169689Skan if (extra_warnings || warn_unused_value) 8023169689Skan { 8024169689Skan for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 8025169689Skan emit_side_effect_warnings (tsi_stmt (i)); 8026169689Skan } 8027169689Skan else 8028169689Skan i = tsi_last (last); 8029169689Skan last_p = tsi_stmt_ptr (i); 8030169689Skan last = *last_p; 8031169689Skan } 8032169689Skan 8033169689Skan /* If the end of the list is exception related, then the list was split 8034169689Skan by a call to push_cleanup. Continue searching. */ 8035169689Skan if (TREE_CODE (last) == TRY_FINALLY_EXPR 8036169689Skan || TREE_CODE (last) == TRY_CATCH_EXPR) 8037169689Skan { 8038169689Skan last_p = &TREE_OPERAND (last, 0); 8039169689Skan last = *last_p; 8040169689Skan goto continue_searching; 8041169689Skan } 8042169689Skan 8043169689Skan /* In the case that the BIND_EXPR is not necessary, return the 8044169689Skan expression out from inside it. */ 8045169689Skan if (last == error_mark_node 8046169689Skan || (last == BIND_EXPR_BODY (body) 8047169689Skan && BIND_EXPR_VARS (body) == NULL)) 8048169689Skan { 8049169689Skan /* Do not warn if the return value of a statement expression is 8050169689Skan unused. */ 8051169689Skan if (EXPR_P (last)) 8052169689Skan TREE_NO_WARNING (last) = 1; 8053169689Skan return last; 8054169689Skan } 8055169689Skan 8056169689Skan /* Extract the type of said expression. */ 8057169689Skan type = TREE_TYPE (last); 8058169689Skan 8059169689Skan /* If we're not returning a value at all, then the BIND_EXPR that 8060169689Skan we already have is a fine expression to return. */ 8061169689Skan if (!type || VOID_TYPE_P (type)) 8062169689Skan return body; 8063169689Skan 8064169689Skan /* Now that we've located the expression containing the value, it seems 8065169689Skan silly to make voidify_wrapper_expr repeat the process. Create a 8066169689Skan temporary of the appropriate type and stick it in a TARGET_EXPR. */ 8067169689Skan tmp = create_tmp_var_raw (type, NULL); 8068169689Skan 8069169689Skan /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 8070169689Skan tree_expr_nonnegative_p giving up immediately. */ 8071169689Skan val = last; 8072169689Skan if (TREE_CODE (val) == NOP_EXPR 8073169689Skan && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 8074169689Skan val = TREE_OPERAND (val, 0); 8075169689Skan 8076169689Skan *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 8077169689Skan SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 8078169689Skan 8079169689Skan return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 8080169689Skan} 8081169689Skan 8082169689Skan/* Begin the scope of an identifier of variably modified type, scope 8083169689Skan number SCOPE. Jumping from outside this scope to inside it is not 8084169689Skan permitted. */ 8085169689Skan 8086169689Skanvoid 8087169689Skanc_begin_vm_scope (unsigned int scope) 8088169689Skan{ 8089169689Skan struct c_label_context_vm *nstack; 8090169689Skan struct c_label_list *glist; 8091169689Skan 8092169689Skan gcc_assert (scope > 0); 8093169689Skan 8094169689Skan /* At file_scope, we don't have to do any processing. */ 8095169689Skan if (label_context_stack_vm == NULL) 8096169689Skan return; 8097169689Skan 8098169689Skan if (c_switch_stack && !c_switch_stack->blocked_vm) 8099169689Skan c_switch_stack->blocked_vm = scope; 8100169689Skan for (glist = label_context_stack_vm->labels_used; 8101169689Skan glist != NULL; 8102169689Skan glist = glist->next) 8103169689Skan { 8104169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 1; 8105169689Skan } 8106169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 8107169689Skan nstack->labels_def = NULL; 8108169689Skan nstack->labels_used = NULL; 8109169689Skan nstack->scope = scope; 8110169689Skan nstack->next = label_context_stack_vm; 8111169689Skan label_context_stack_vm = nstack; 8112169689Skan} 8113169689Skan 8114169689Skan/* End a scope which may contain identifiers of variably modified 8115169689Skan type, scope number SCOPE. */ 8116169689Skan 8117169689Skanvoid 8118169689Skanc_end_vm_scope (unsigned int scope) 8119169689Skan{ 8120169689Skan if (label_context_stack_vm == NULL) 8121169689Skan return; 8122169689Skan if (c_switch_stack && c_switch_stack->blocked_vm == scope) 8123169689Skan c_switch_stack->blocked_vm = 0; 8124169689Skan /* We may have a number of nested scopes of identifiers with 8125169689Skan variably modified type, all at this depth. Pop each in turn. */ 8126169689Skan while (label_context_stack_vm->scope == scope) 8127169689Skan { 8128169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 8129169689Skan 8130169689Skan /* It is no longer possible to jump to labels defined within this 8131169689Skan scope. */ 8132169689Skan for (dlist = label_context_stack_vm->labels_def; 8133169689Skan dlist != NULL; 8134169689Skan dlist = dlist->next) 8135169689Skan { 8136169689Skan C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 8137169689Skan } 8138169689Skan /* It is again possible to define labels with a goto just outside 8139169689Skan this scope. */ 8140169689Skan for (glist = label_context_stack_vm->next->labels_used; 8141169689Skan glist != NULL; 8142169689Skan glist = glist->next) 8143169689Skan { 8144169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 0; 8145169689Skan glist_prev = glist; 8146169689Skan } 8147169689Skan if (glist_prev != NULL) 8148169689Skan glist_prev->next = label_context_stack_vm->labels_used; 8149169689Skan else 8150169689Skan label_context_stack_vm->next->labels_used 8151169689Skan = label_context_stack_vm->labels_used; 8152169689Skan label_context_stack_vm = label_context_stack_vm->next; 8153169689Skan } 8154169689Skan} 8155169689Skan 8156169689Skan/* Begin and end compound statements. This is as simple as pushing 8157169689Skan and popping new statement lists from the tree. */ 8158169689Skan 8159169689Skantree 8160169689Skanc_begin_compound_stmt (bool do_scope) 8161169689Skan{ 8162169689Skan tree stmt = push_stmt_list (); 8163169689Skan if (do_scope) 8164169689Skan push_scope (); 8165169689Skan return stmt; 8166169689Skan} 8167169689Skan 8168169689Skantree 8169169689Skanc_end_compound_stmt (tree stmt, bool do_scope) 8170169689Skan{ 8171169689Skan tree block = NULL; 8172169689Skan 8173169689Skan if (do_scope) 8174169689Skan { 8175169689Skan if (c_dialect_objc ()) 8176169689Skan objc_clear_super_receiver (); 8177169689Skan block = pop_scope (); 8178169689Skan } 8179169689Skan 8180169689Skan stmt = pop_stmt_list (stmt); 8181169689Skan stmt = c_build_bind_expr (block, stmt); 8182169689Skan 8183169689Skan /* If this compound statement is nested immediately inside a statement 8184169689Skan expression, then force a BIND_EXPR to be created. Otherwise we'll 8185169689Skan do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 8186169689Skan STATEMENT_LISTs merge, and thus we can lose track of what statement 8187169689Skan was really last. */ 8188169689Skan if (cur_stmt_list 8189169689Skan && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 8190169689Skan && TREE_CODE (stmt) != BIND_EXPR) 8191169689Skan { 8192169689Skan stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 8193169689Skan TREE_SIDE_EFFECTS (stmt) = 1; 8194169689Skan } 8195169689Skan 8196169689Skan return stmt; 8197169689Skan} 8198169689Skan 8199169689Skan/* Queue a cleanup. CLEANUP is an expression/statement to be executed 8200169689Skan when the current scope is exited. EH_ONLY is true when this is not 8201169689Skan meant to apply to normal control flow transfer. */ 8202169689Skan 8203169689Skanvoid 8204169689Skanpush_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 8205169689Skan{ 8206169689Skan enum tree_code code; 8207169689Skan tree stmt, list; 8208169689Skan bool stmt_expr; 8209169689Skan 8210169689Skan code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 8211169689Skan stmt = build_stmt (code, NULL, cleanup); 8212169689Skan add_stmt (stmt); 8213169689Skan stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 8214169689Skan list = push_stmt_list (); 8215169689Skan TREE_OPERAND (stmt, 0) = list; 8216169689Skan STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 8217169689Skan} 8218169689Skan 8219132718Skan/* Build a binary-operation expression without default conversions. 8220132718Skan CODE is the kind of expression to build. 8221132718Skan This function differs from `build' in several ways: 8222132718Skan the data type of the result is computed and recorded in it, 8223132718Skan warnings are generated if arg data types are invalid, 8224132718Skan special handling for addition and subtraction of pointers is known, 8225132718Skan and some optimization is done (operations on narrow ints 8226132718Skan are done in the narrower type when that gives the same result). 8227132718Skan Constant folding is also done before the result is returned. 8228132718Skan 8229132718Skan Note that the operands will never have enumeral types, or function 8230132718Skan or array types, because either they will have the default conversions 8231132718Skan performed or they have both just been converted to some other type in which 8232132718Skan the arithmetic is to be done. */ 8233132718Skan 8234132718Skantree 8235132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 8236132718Skan int convert_p) 8237132718Skan{ 8238132718Skan tree type0, type1; 8239132718Skan enum tree_code code0, code1; 8240132718Skan tree op0, op1; 8241169689Skan const char *invalid_op_diag; 8242132718Skan 8243132718Skan /* Expression code to give to the expression when it is built. 8244132718Skan Normally this is CODE, which is what the caller asked for, 8245132718Skan but in some special cases we change it. */ 8246132718Skan enum tree_code resultcode = code; 8247132718Skan 8248132718Skan /* Data type in which the computation is to be performed. 8249132718Skan In the simplest cases this is the common type of the arguments. */ 8250132718Skan tree result_type = NULL; 8251132718Skan 8252132718Skan /* Nonzero means operands have already been type-converted 8253132718Skan in whatever way is necessary. 8254132718Skan Zero means they need to be converted to RESULT_TYPE. */ 8255132718Skan int converted = 0; 8256132718Skan 8257132718Skan /* Nonzero means create the expression with this type, rather than 8258132718Skan RESULT_TYPE. */ 8259132718Skan tree build_type = 0; 8260132718Skan 8261132718Skan /* Nonzero means after finally constructing the expression 8262132718Skan convert it to this type. */ 8263132718Skan tree final_type = 0; 8264132718Skan 8265132718Skan /* Nonzero if this is an operation like MIN or MAX which can 8266132718Skan safely be computed in short if both args are promoted shorts. 8267132718Skan Also implies COMMON. 8268132718Skan -1 indicates a bitwise operation; this makes a difference 8269132718Skan in the exact conditions for when it is safe to do the operation 8270132718Skan in a narrower mode. */ 8271132718Skan int shorten = 0; 8272132718Skan 8273132718Skan /* Nonzero if this is a comparison operation; 8274132718Skan if both args are promoted shorts, compare the original shorts. 8275132718Skan Also implies COMMON. */ 8276132718Skan int short_compare = 0; 8277132718Skan 8278132718Skan /* Nonzero if this is a right-shift operation, which can be computed on the 8279132718Skan original short and then promoted if the operand is a promoted short. */ 8280132718Skan int short_shift = 0; 8281132718Skan 8282132718Skan /* Nonzero means set RESULT_TYPE to the common type of the args. */ 8283132718Skan int common = 0; 8284132718Skan 8285169689Skan /* True means types are compatible as far as ObjC is concerned. */ 8286169689Skan bool objc_ok; 8287169689Skan 8288132718Skan if (convert_p) 8289132718Skan { 8290132718Skan op0 = default_conversion (orig_op0); 8291132718Skan op1 = default_conversion (orig_op1); 8292132718Skan } 8293132718Skan else 8294132718Skan { 8295132718Skan op0 = orig_op0; 8296132718Skan op1 = orig_op1; 8297132718Skan } 8298132718Skan 8299132718Skan type0 = TREE_TYPE (op0); 8300132718Skan type1 = TREE_TYPE (op1); 8301132718Skan 8302132718Skan /* The expression codes of the data types of the arguments tell us 8303132718Skan whether the arguments are integers, floating, pointers, etc. */ 8304132718Skan code0 = TREE_CODE (type0); 8305132718Skan code1 = TREE_CODE (type1); 8306132718Skan 8307132718Skan /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 8308132718Skan STRIP_TYPE_NOPS (op0); 8309132718Skan STRIP_TYPE_NOPS (op1); 8310132718Skan 8311132718Skan /* If an error was already reported for one of the arguments, 8312132718Skan avoid reporting another error. */ 8313132718Skan 8314132718Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8315132718Skan return error_mark_node; 8316132718Skan 8317169689Skan if ((invalid_op_diag 8318169689Skan = targetm.invalid_binary_op (code, type0, type1))) 8319169689Skan { 8320259666Spfg error (invalid_op_diag, ""); 8321169689Skan return error_mark_node; 8322169689Skan } 8323169689Skan 8324260311Spfg objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE, "comparison"); 8325169689Skan 8326132718Skan switch (code) 8327132718Skan { 8328132718Skan case PLUS_EXPR: 8329132718Skan /* Handle the pointer + int case. */ 8330132718Skan if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8331132718Skan return pointer_int_sum (PLUS_EXPR, op0, op1); 8332132718Skan else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 8333132718Skan return pointer_int_sum (PLUS_EXPR, op1, op0); 8334132718Skan else 8335132718Skan common = 1; 8336132718Skan break; 8337132718Skan 8338132718Skan case MINUS_EXPR: 8339132718Skan /* Subtraction of two similar pointers. 8340132718Skan We must subtract them as integers, then divide by object size. */ 8341132718Skan if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 8342169689Skan && comp_target_types (type0, type1)) 8343132718Skan return pointer_diff (op0, op1); 8344132718Skan /* Handle pointer minus int. Just like pointer plus int. */ 8345132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8346132718Skan return pointer_int_sum (MINUS_EXPR, op0, op1); 8347132718Skan else 8348132718Skan common = 1; 8349132718Skan break; 8350132718Skan 8351132718Skan case MULT_EXPR: 8352132718Skan common = 1; 8353132718Skan break; 8354132718Skan 8355132718Skan case TRUNC_DIV_EXPR: 8356132718Skan case CEIL_DIV_EXPR: 8357132718Skan case FLOOR_DIV_EXPR: 8358132718Skan case ROUND_DIV_EXPR: 8359132718Skan case EXACT_DIV_EXPR: 8360132718Skan /* Floating point division by zero is a legitimate way to obtain 8361132718Skan infinities and NaNs. */ 8362169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 8363169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 8364132718Skan 8365132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8366132718Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 8367132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8368132718Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 8369132718Skan { 8370169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 8371169689Skan 8372169689Skan if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 8373169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 8374169689Skan if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 8375169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 8376169689Skan 8377169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 8378132718Skan resultcode = RDIV_EXPR; 8379132718Skan else 8380132718Skan /* Although it would be tempting to shorten always here, that 8381132718Skan loses on some targets, since the modulo instruction is 8382132718Skan undefined if the quotient can't be represented in the 8383132718Skan computation mode. We shorten only if unsigned or if 8384132718Skan dividing by something we know != -1. */ 8385169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 8386132718Skan || (TREE_CODE (op1) == INTEGER_CST 8387169689Skan && !integer_all_onesp (op1))); 8388132718Skan common = 1; 8389132718Skan } 8390132718Skan break; 8391132718Skan 8392132718Skan case BIT_AND_EXPR: 8393132718Skan case BIT_IOR_EXPR: 8394132718Skan case BIT_XOR_EXPR: 8395132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8396132718Skan shorten = -1; 8397132718Skan else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 8398132718Skan common = 1; 8399132718Skan break; 8400132718Skan 8401132718Skan case TRUNC_MOD_EXPR: 8402132718Skan case FLOOR_MOD_EXPR: 8403169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 8404169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 8405132718Skan 8406132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8407132718Skan { 8408132718Skan /* Although it would be tempting to shorten always here, that loses 8409132718Skan on some targets, since the modulo instruction is undefined if the 8410132718Skan quotient can't be represented in the computation mode. We shorten 8411132718Skan only if unsigned or if dividing by something we know != -1. */ 8412169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 8413132718Skan || (TREE_CODE (op1) == INTEGER_CST 8414169689Skan && !integer_all_onesp (op1))); 8415132718Skan common = 1; 8416132718Skan } 8417132718Skan break; 8418132718Skan 8419132718Skan case TRUTH_ANDIF_EXPR: 8420132718Skan case TRUTH_ORIF_EXPR: 8421132718Skan case TRUTH_AND_EXPR: 8422132718Skan case TRUTH_OR_EXPR: 8423132718Skan case TRUTH_XOR_EXPR: 8424132718Skan if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 8425260311Spfg /* APPLE LOCAL radar 5928316 */ 8426260311Spfg || code0 == BLOCK_POINTER_TYPE 8427132718Skan || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 8428132718Skan && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 8429260311Spfg /* APPLE LOCAL radar 5928316 */ 8430260311Spfg || code1 == BLOCK_POINTER_TYPE 8431132718Skan || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 8432132718Skan { 8433132718Skan /* Result of these operations is always an int, 8434132718Skan but that does not mean the operands should be 8435132718Skan converted to ints! */ 8436132718Skan result_type = integer_type_node; 8437132718Skan op0 = c_common_truthvalue_conversion (op0); 8438132718Skan op1 = c_common_truthvalue_conversion (op1); 8439132718Skan converted = 1; 8440132718Skan } 8441132718Skan break; 8442132718Skan 8443132718Skan /* Shift operations: result has same type as first operand; 8444132718Skan always convert second operand to int. 8445132718Skan Also set SHORT_SHIFT if shifting rightward. */ 8446132718Skan 8447132718Skan case RSHIFT_EXPR: 8448132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8449132718Skan { 8450132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8451132718Skan { 8452132718Skan if (tree_int_cst_sgn (op1) < 0) 8453169689Skan warning (0, "right shift count is negative"); 8454132718Skan else 8455132718Skan { 8456169689Skan if (!integer_zerop (op1)) 8457132718Skan short_shift = 1; 8458132718Skan 8459132718Skan if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8460169689Skan warning (0, "right shift count >= width of type"); 8461132718Skan } 8462132718Skan } 8463132718Skan 8464132718Skan /* Use the type of the value to be shifted. */ 8465132718Skan result_type = type0; 8466132718Skan /* Convert the shift-count to an integer, regardless of size 8467132718Skan of value being shifted. */ 8468132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8469132718Skan op1 = convert (integer_type_node, op1); 8470132718Skan /* Avoid converting op1 to result_type later. */ 8471132718Skan converted = 1; 8472132718Skan } 8473132718Skan break; 8474132718Skan 8475132718Skan case LSHIFT_EXPR: 8476132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8477132718Skan { 8478132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8479132718Skan { 8480132718Skan if (tree_int_cst_sgn (op1) < 0) 8481169689Skan warning (0, "left shift count is negative"); 8482132718Skan 8483132718Skan else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8484169689Skan warning (0, "left shift count >= width of type"); 8485132718Skan } 8486132718Skan 8487132718Skan /* Use the type of the value to be shifted. */ 8488132718Skan result_type = type0; 8489132718Skan /* Convert the shift-count to an integer, regardless of size 8490132718Skan of value being shifted. */ 8491132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8492132718Skan op1 = convert (integer_type_node, op1); 8493132718Skan /* Avoid converting op1 to result_type later. */ 8494132718Skan converted = 1; 8495132718Skan } 8496132718Skan break; 8497132718Skan 8498132718Skan case EQ_EXPR: 8499132718Skan case NE_EXPR: 8500169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 8501169689Skan warning (OPT_Wfloat_equal, 8502169689Skan "comparing floating point with == or != is unsafe"); 8503132718Skan /* Result of comparison is always int, 8504132718Skan but don't convert the args to int! */ 8505132718Skan build_type = integer_type_node; 8506132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8507132718Skan || code0 == COMPLEX_TYPE) 8508132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8509132718Skan || code1 == COMPLEX_TYPE)) 8510132718Skan short_compare = 1; 8511260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 8512260311Spfg else if ((code0 == POINTER_TYPE || code0 == BLOCK_POINTER_TYPE) 8513260311Spfg && (code1 == POINTER_TYPE || code1 == BLOCK_POINTER_TYPE)) 8514260311Spfg /* APPLE LOCAL end blocks 6065211 */ 8515132718Skan { 8516132718Skan tree tt0 = TREE_TYPE (type0); 8517132718Skan tree tt1 = TREE_TYPE (type1); 8518132718Skan /* Anything compares with void *. void * compares with anything. 8519132718Skan Otherwise, the targets must be compatible 8520132718Skan and both must be object or both incomplete. */ 8521169689Skan if (comp_target_types (type0, type1)) 8522169689Skan result_type = common_pointer_type (type0, type1); 8523260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 8524260311Spfg else if (code1 == BLOCK_POINTER_TYPE && VOID_TYPE_P (tt0)) 8525260311Spfg ; 8526260311Spfg else if (code0 == BLOCK_POINTER_TYPE && VOID_TYPE_P (tt1)) 8527260311Spfg ; 8528260311Spfg /* APPLE LOCAL end blocks 6065211 */ 8529132718Skan else if (VOID_TYPE_P (tt0)) 8530132718Skan { 8531132718Skan /* op0 != orig_op0 detects the case of something 8532132718Skan whose value is 0 but which isn't a valid null ptr const. */ 8533169689Skan if (pedantic && !null_pointer_constant_p (orig_op0) 8534132718Skan && TREE_CODE (tt1) == FUNCTION_TYPE) 8535169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8536169689Skan " with function pointer"); 8537132718Skan } 8538132718Skan else if (VOID_TYPE_P (tt1)) 8539132718Skan { 8540169689Skan if (pedantic && !null_pointer_constant_p (orig_op1) 8541132718Skan && TREE_CODE (tt0) == FUNCTION_TYPE) 8542169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8543169689Skan " with function pointer"); 8544132718Skan } 8545132718Skan else 8546169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 8547169689Skan if (!objc_ok) 8548260311Spfg /* APPLE LOCAL begin blocks 6065211 */ 8549260311Spfg { 8550260311Spfg if (code0 == BLOCK_POINTER_TYPE || code1 == BLOCK_POINTER_TYPE) 8551260311Spfg pedwarn ("comparison of distinct block types lacks a cast"); 8552260311Spfg else 8553260311Spfg pedwarn ("comparison of distinct pointer types lacks a cast"); 8554260311Spfg } 8555260311Spfg /* APPLE LOCAL end blocks 6065211 */ 8556132718Skan 8557132718Skan if (result_type == NULL_TREE) 8558132718Skan result_type = ptr_type_node; 8559132718Skan } 8560169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8561169689Skan { 8562169689Skan if (TREE_CODE (op0) == ADDR_EXPR 8563169689Skan && DECL_P (TREE_OPERAND (op0, 0)) 8564169689Skan && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8565169689Skan || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8566169689Skan || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8567169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8568169689Skan TREE_OPERAND (op0, 0)); 8569169689Skan result_type = type0; 8570169689Skan } 8571169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8572169689Skan { 8573169689Skan if (TREE_CODE (op1) == ADDR_EXPR 8574169689Skan && DECL_P (TREE_OPERAND (op1, 0)) 8575169689Skan && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8576169689Skan || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8577169689Skan || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8578169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8579169689Skan TREE_OPERAND (op1, 0)); 8580169689Skan result_type = type1; 8581169689Skan } 8582132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8583132718Skan { 8584132718Skan result_type = type0; 8585132718Skan pedwarn ("comparison between pointer and integer"); 8586132718Skan } 8587132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8588132718Skan { 8589132718Skan result_type = type1; 8590132718Skan pedwarn ("comparison between pointer and integer"); 8591132718Skan } 8592260311Spfg /* APPLE LOCAL begin radar 5732232 - blocks (C++ cl) */ 8593260311Spfg else if (code0 == BLOCK_POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8594260311Spfg result_type = type0; 8595260311Spfg else if (code1 == BLOCK_POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8596260311Spfg result_type = type1; 8597260311Spfg /* APPLE LOCAL end radar 5732232 - blocks (C++ cl) */ 8598132718Skan break; 8599132718Skan 8600132718Skan case LE_EXPR: 8601132718Skan case GE_EXPR: 8602132718Skan case LT_EXPR: 8603132718Skan case GT_EXPR: 8604132718Skan build_type = integer_type_node; 8605132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8606132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8607132718Skan short_compare = 1; 8608132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8609132718Skan { 8610169689Skan if (comp_target_types (type0, type1)) 8611132718Skan { 8612169689Skan result_type = common_pointer_type (type0, type1); 8613132718Skan if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8614132718Skan != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8615132718Skan pedwarn ("comparison of complete and incomplete pointers"); 8616132718Skan else if (pedantic 8617132718Skan && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8618132718Skan pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8619132718Skan } 8620132718Skan else 8621132718Skan { 8622132718Skan result_type = ptr_type_node; 8623132718Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8624132718Skan } 8625132718Skan } 8626169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8627132718Skan { 8628132718Skan result_type = type0; 8629132718Skan if (pedantic || extra_warnings) 8630132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8631132718Skan } 8632169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8633132718Skan { 8634132718Skan result_type = type1; 8635132718Skan if (pedantic) 8636132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8637132718Skan } 8638132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8639132718Skan { 8640132718Skan result_type = type0; 8641132718Skan pedwarn ("comparison between pointer and integer"); 8642132718Skan } 8643132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8644132718Skan { 8645132718Skan result_type = type1; 8646132718Skan pedwarn ("comparison between pointer and integer"); 8647132718Skan } 8648132718Skan break; 8649132718Skan 8650132718Skan default: 8651169689Skan gcc_unreachable (); 8652132718Skan } 8653132718Skan 8654169689Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8655169689Skan return error_mark_node; 8656169689Skan 8657169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8658169689Skan && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8659169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8660169689Skan TREE_TYPE (type1)))) 8661169689Skan { 8662259022Spfg binary_op_error (code, type0, type1); 8663169689Skan return error_mark_node; 8664169689Skan } 8665169689Skan 8666132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8667132718Skan || code0 == VECTOR_TYPE) 8668132718Skan && 8669132718Skan (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8670132718Skan || code1 == VECTOR_TYPE)) 8671132718Skan { 8672132718Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8673132718Skan 8674132718Skan if (shorten || common || short_compare) 8675169689Skan result_type = c_common_type (type0, type1); 8676132718Skan 8677132718Skan /* For certain operations (which identify themselves by shorten != 0) 8678132718Skan if both args were extended from the same smaller type, 8679132718Skan do the arithmetic in that type and then extend. 8680132718Skan 8681132718Skan shorten !=0 and !=1 indicates a bitwise operation. 8682132718Skan For them, this optimization is safe only if 8683132718Skan both args are zero-extended or both are sign-extended. 8684132718Skan Otherwise, we might change the result. 8685132718Skan Eg, (short)-1 | (unsigned short)-1 is (int)-1 8686132718Skan but calculated in (unsigned short) it would be (unsigned short)-1. */ 8687132718Skan 8688132718Skan if (shorten && none_complex) 8689132718Skan { 8690132718Skan int unsigned0, unsigned1; 8691169689Skan tree arg0, arg1; 8692169689Skan int uns; 8693132718Skan tree type; 8694132718Skan 8695169689Skan /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8696169689Skan excessive narrowing when we call get_narrower below. For 8697169689Skan example, suppose that OP0 is of unsigned int extended 8698169689Skan from signed char and that RESULT_TYPE is long long int. 8699169689Skan If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8700169689Skan like 8701169689Skan 8702169689Skan (long long int) (unsigned int) signed_char 8703169689Skan 8704169689Skan which get_narrower would narrow down to 8705169689Skan 8706169689Skan (unsigned int) signed char 8707169689Skan 8708169689Skan If we do not cast OP0 first, get_narrower would return 8709169689Skan signed_char, which is inconsistent with the case of the 8710169689Skan explicit cast. */ 8711169689Skan op0 = convert (result_type, op0); 8712169689Skan op1 = convert (result_type, op1); 8713169689Skan 8714169689Skan arg0 = get_narrower (op0, &unsigned0); 8715169689Skan arg1 = get_narrower (op1, &unsigned1); 8716169689Skan 8717169689Skan /* UNS is 1 if the operation to be done is an unsigned one. */ 8718169689Skan uns = TYPE_UNSIGNED (result_type); 8719169689Skan 8720132718Skan final_type = result_type; 8721132718Skan 8722132718Skan /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8723132718Skan but it *requires* conversion to FINAL_TYPE. */ 8724132718Skan 8725132718Skan if ((TYPE_PRECISION (TREE_TYPE (op0)) 8726132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8727132718Skan && TREE_TYPE (op0) != final_type) 8728169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8729132718Skan if ((TYPE_PRECISION (TREE_TYPE (op1)) 8730132718Skan == TYPE_PRECISION (TREE_TYPE (arg1))) 8731132718Skan && TREE_TYPE (op1) != final_type) 8732169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8733132718Skan 8734132718Skan /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8735132718Skan 8736132718Skan /* For bitwise operations, signedness of nominal type 8737132718Skan does not matter. Consider only how operands were extended. */ 8738132718Skan if (shorten == -1) 8739132718Skan uns = unsigned0; 8740132718Skan 8741132718Skan /* Note that in all three cases below we refrain from optimizing 8742132718Skan an unsigned operation on sign-extended args. 8743132718Skan That would not be valid. */ 8744132718Skan 8745132718Skan /* Both args variable: if both extended in same way 8746132718Skan from same width, do it in that width. 8747132718Skan Do it unsigned if args were zero-extended. */ 8748132718Skan if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8749132718Skan < TYPE_PRECISION (result_type)) 8750132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8751132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8752132718Skan && unsigned0 == unsigned1 8753132718Skan && (unsigned0 || !uns)) 8754132718Skan result_type 8755132718Skan = c_common_signed_or_unsigned_type 8756132718Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8757132718Skan else if (TREE_CODE (arg0) == INTEGER_CST 8758132718Skan && (unsigned1 || !uns) 8759132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8760132718Skan < TYPE_PRECISION (result_type)) 8761132718Skan && (type 8762132718Skan = c_common_signed_or_unsigned_type (unsigned1, 8763132718Skan TREE_TYPE (arg1)), 8764132718Skan int_fits_type_p (arg0, type))) 8765132718Skan result_type = type; 8766132718Skan else if (TREE_CODE (arg1) == INTEGER_CST 8767132718Skan && (unsigned0 || !uns) 8768132718Skan && (TYPE_PRECISION (TREE_TYPE (arg0)) 8769132718Skan < TYPE_PRECISION (result_type)) 8770132718Skan && (type 8771132718Skan = c_common_signed_or_unsigned_type (unsigned0, 8772132718Skan TREE_TYPE (arg0)), 8773132718Skan int_fits_type_p (arg1, type))) 8774132718Skan result_type = type; 8775132718Skan } 8776132718Skan 8777132718Skan /* Shifts can be shortened if shifting right. */ 8778132718Skan 8779132718Skan if (short_shift) 8780132718Skan { 8781132718Skan int unsigned_arg; 8782132718Skan tree arg0 = get_narrower (op0, &unsigned_arg); 8783132718Skan 8784132718Skan final_type = result_type; 8785132718Skan 8786132718Skan if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8787169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8788132718Skan 8789132718Skan if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8790132718Skan /* We can shorten only if the shift count is less than the 8791132718Skan number of bits in the smaller type size. */ 8792132718Skan && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8793132718Skan /* We cannot drop an unsigned shift after sign-extension. */ 8794169689Skan && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8795132718Skan { 8796132718Skan /* Do an unsigned shift if the operand was zero-extended. */ 8797132718Skan result_type 8798132718Skan = c_common_signed_or_unsigned_type (unsigned_arg, 8799132718Skan TREE_TYPE (arg0)); 8800132718Skan /* Convert value-to-be-shifted to that type. */ 8801132718Skan if (TREE_TYPE (op0) != result_type) 8802132718Skan op0 = convert (result_type, op0); 8803132718Skan converted = 1; 8804132718Skan } 8805132718Skan } 8806132718Skan 8807132718Skan /* Comparison operations are shortened too but differently. 8808132718Skan They identify themselves by setting short_compare = 1. */ 8809132718Skan 8810132718Skan if (short_compare) 8811132718Skan { 8812132718Skan /* Don't write &op0, etc., because that would prevent op0 8813132718Skan from being kept in a register. 8814132718Skan Instead, make copies of the our local variables and 8815132718Skan pass the copies by reference, then copy them back afterward. */ 8816132718Skan tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8817132718Skan enum tree_code xresultcode = resultcode; 8818132718Skan tree val 8819132718Skan = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8820132718Skan 8821132718Skan if (val != 0) 8822132718Skan return val; 8823132718Skan 8824132718Skan op0 = xop0, op1 = xop1; 8825132718Skan converted = 1; 8826132718Skan resultcode = xresultcode; 8827132718Skan 8828132718Skan if (warn_sign_compare && skip_evaluation == 0) 8829132718Skan { 8830169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8831169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8832132718Skan int unsignedp0, unsignedp1; 8833132718Skan tree primop0 = get_narrower (op0, &unsignedp0); 8834132718Skan tree primop1 = get_narrower (op1, &unsignedp1); 8835132718Skan 8836132718Skan xop0 = orig_op0; 8837132718Skan xop1 = orig_op1; 8838132718Skan STRIP_TYPE_NOPS (xop0); 8839132718Skan STRIP_TYPE_NOPS (xop1); 8840132718Skan 8841132718Skan /* Give warnings for comparisons between signed and unsigned 8842132718Skan quantities that may fail. 8843132718Skan 8844132718Skan Do the checking based on the original operand trees, so that 8845132718Skan casts will be considered, but default promotions won't be. 8846132718Skan 8847132718Skan Do not warn if the comparison is being done in a signed type, 8848132718Skan since the signed type will only be chosen if it can represent 8849132718Skan all the values of the unsigned type. */ 8850169689Skan if (!TYPE_UNSIGNED (result_type)) 8851132718Skan /* OK */; 8852169689Skan /* Do not warn if both operands are the same signedness. */ 8853169689Skan else if (op0_signed == op1_signed) 8854169689Skan /* OK */; 8855132718Skan else 8856132718Skan { 8857132718Skan tree sop, uop; 8858169689Skan bool ovf; 8859132718Skan 8860132718Skan if (op0_signed) 8861132718Skan sop = xop0, uop = xop1; 8862132718Skan else 8863132718Skan sop = xop1, uop = xop0; 8864132718Skan 8865132718Skan /* Do not warn if the signed quantity is an 8866132718Skan unsuffixed integer literal (or some static 8867132718Skan constant expression involving such literals or a 8868132718Skan conditional expression involving such literals) 8869132718Skan and it is non-negative. */ 8870169689Skan if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8871132718Skan /* OK */; 8872132718Skan /* Do not warn if the comparison is an equality operation, 8873132718Skan the unsigned quantity is an integral constant, and it 8874132718Skan would fit in the result if the result were signed. */ 8875132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8876132718Skan && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8877132718Skan && int_fits_type_p 8878132718Skan (uop, c_common_signed_type (result_type))) 8879132718Skan /* OK */; 8880132718Skan /* Do not warn if the unsigned quantity is an enumeration 8881132718Skan constant and its maximum value would fit in the result 8882132718Skan if the result were signed. */ 8883132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8884132718Skan && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8885132718Skan && int_fits_type_p 8886169689Skan (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8887132718Skan c_common_signed_type (result_type))) 8888132718Skan /* OK */; 8889132718Skan else 8890169689Skan warning (0, "comparison between signed and unsigned"); 8891132718Skan } 8892132718Skan 8893132718Skan /* Warn if two unsigned values are being compared in a size 8894132718Skan larger than their original size, and one (and only one) is the 8895132718Skan result of a `~' operator. This comparison will always fail. 8896132718Skan 8897132718Skan Also warn if one operand is a constant, and the constant 8898132718Skan does not have all bits set that are set in the ~ operand 8899132718Skan when it is extended. */ 8900132718Skan 8901132718Skan if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8902132718Skan != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8903132718Skan { 8904132718Skan if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8905132718Skan primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8906132718Skan &unsignedp0); 8907132718Skan else 8908132718Skan primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8909132718Skan &unsignedp1); 8910132718Skan 8911132718Skan if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8912132718Skan { 8913132718Skan tree primop; 8914132718Skan HOST_WIDE_INT constant, mask; 8915132718Skan int unsignedp, bits; 8916132718Skan 8917132718Skan if (host_integerp (primop0, 0)) 8918132718Skan { 8919132718Skan primop = primop1; 8920132718Skan unsignedp = unsignedp1; 8921132718Skan constant = tree_low_cst (primop0, 0); 8922132718Skan } 8923132718Skan else 8924132718Skan { 8925132718Skan primop = primop0; 8926132718Skan unsignedp = unsignedp0; 8927132718Skan constant = tree_low_cst (primop1, 0); 8928132718Skan } 8929132718Skan 8930132718Skan bits = TYPE_PRECISION (TREE_TYPE (primop)); 8931132718Skan if (bits < TYPE_PRECISION (result_type) 8932132718Skan && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8933132718Skan { 8934169689Skan mask = (~(HOST_WIDE_INT) 0) << bits; 8935132718Skan if ((mask & constant) != mask) 8936169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 8937132718Skan } 8938132718Skan } 8939132718Skan else if (unsignedp0 && unsignedp1 8940132718Skan && (TYPE_PRECISION (TREE_TYPE (primop0)) 8941132718Skan < TYPE_PRECISION (result_type)) 8942132718Skan && (TYPE_PRECISION (TREE_TYPE (primop1)) 8943132718Skan < TYPE_PRECISION (result_type))) 8944169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 8945132718Skan } 8946132718Skan } 8947132718Skan } 8948132718Skan } 8949132718Skan 8950132718Skan /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8951132718Skan If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8952132718Skan Then the expression will be built. 8953132718Skan It will be given type FINAL_TYPE if that is nonzero; 8954132718Skan otherwise, it will be given type RESULT_TYPE. */ 8955132718Skan 8956132718Skan if (!result_type) 8957132718Skan { 8958259022Spfg binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1)); 8959132718Skan return error_mark_node; 8960132718Skan } 8961132718Skan 8962169689Skan if (!converted) 8963132718Skan { 8964132718Skan if (TREE_TYPE (op0) != result_type) 8965169689Skan op0 = convert_and_check (result_type, op0); 8966132718Skan if (TREE_TYPE (op1) != result_type) 8967169689Skan op1 = convert_and_check (result_type, op1); 8968169689Skan 8969169689Skan /* This can happen if one operand has a vector type, and the other 8970169689Skan has a different type. */ 8971169689Skan if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8972169689Skan return error_mark_node; 8973132718Skan } 8974132718Skan 8975132718Skan if (build_type == NULL_TREE) 8976132718Skan build_type = result_type; 8977132718Skan 8978132718Skan { 8979169689Skan /* Treat expressions in initializers specially as they can't trap. */ 8980169689Skan tree result = require_constant_value ? fold_build2_initializer (resultcode, 8981169689Skan build_type, 8982169689Skan op0, op1) 8983169689Skan : fold_build2 (resultcode, build_type, 8984169689Skan op0, op1); 8985132718Skan 8986132718Skan if (final_type != 0) 8987169689Skan result = convert (final_type, result); 8988169689Skan return result; 8989132718Skan } 8990132718Skan} 8991169689Skan 8992169689Skan 8993169689Skan/* Convert EXPR to be a truth-value, validating its type for this 8994169689Skan purpose. */ 8995169689Skan 8996169689Skantree 8997169689Skanc_objc_common_truthvalue_conversion (tree expr) 8998169689Skan{ 8999169689Skan switch (TREE_CODE (TREE_TYPE (expr))) 9000169689Skan { 9001169689Skan case ARRAY_TYPE: 9002169689Skan error ("used array that cannot be converted to pointer where scalar is required"); 9003169689Skan return error_mark_node; 9004169689Skan 9005169689Skan case RECORD_TYPE: 9006169689Skan error ("used struct type value where scalar is required"); 9007169689Skan return error_mark_node; 9008169689Skan 9009169689Skan case UNION_TYPE: 9010169689Skan error ("used union type value where scalar is required"); 9011169689Skan return error_mark_node; 9012169689Skan 9013169689Skan case FUNCTION_TYPE: 9014169689Skan gcc_unreachable (); 9015169689Skan 9016169689Skan default: 9017169689Skan break; 9018169689Skan } 9019169689Skan 9020169689Skan /* ??? Should we also give an error for void and vectors rather than 9021169689Skan leaving those to give errors later? */ 9022169689Skan return c_common_truthvalue_conversion (expr); 9023169689Skan} 9024169689Skan 9025169689Skan 9026169689Skan/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 9027169689Skan required. */ 9028169689Skan 9029169689Skantree 9030169689Skanc_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 9031169689Skan bool *ti ATTRIBUTE_UNUSED, bool *se) 9032169689Skan{ 9033169689Skan if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 9034169689Skan { 9035169689Skan tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 9036169689Skan /* Executing a compound literal inside a function reinitializes 9037169689Skan it. */ 9038169689Skan if (!TREE_STATIC (decl)) 9039169689Skan *se = true; 9040169689Skan return decl; 9041169689Skan } 9042169689Skan else 9043169689Skan return expr; 9044169689Skan} 9045169689Skan 9046169689Skan/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 9047169689Skan 9048169689Skantree 9049169689Skanc_begin_omp_parallel (void) 9050169689Skan{ 9051169689Skan tree block; 9052169689Skan 9053169689Skan keep_next_level (); 9054169689Skan block = c_begin_compound_stmt (true); 9055169689Skan 9056169689Skan return block; 9057169689Skan} 9058169689Skan 9059169689Skantree 9060169689Skanc_finish_omp_parallel (tree clauses, tree block) 9061169689Skan{ 9062169689Skan tree stmt; 9063169689Skan 9064169689Skan block = c_end_compound_stmt (block, true); 9065169689Skan 9066169689Skan stmt = make_node (OMP_PARALLEL); 9067169689Skan TREE_TYPE (stmt) = void_type_node; 9068169689Skan OMP_PARALLEL_CLAUSES (stmt) = clauses; 9069169689Skan OMP_PARALLEL_BODY (stmt) = block; 9070169689Skan 9071169689Skan return add_stmt (stmt); 9072169689Skan} 9073169689Skan 9074169689Skan/* For all elements of CLAUSES, validate them vs OpenMP constraints. 9075169689Skan Remove any elements from the list that are invalid. */ 9076169689Skan 9077169689Skantree 9078169689Skanc_finish_omp_clauses (tree clauses) 9079169689Skan{ 9080169689Skan bitmap_head generic_head, firstprivate_head, lastprivate_head; 9081169689Skan tree c, t, *pc = &clauses; 9082169689Skan const char *name; 9083169689Skan 9084169689Skan bitmap_obstack_initialize (NULL); 9085169689Skan bitmap_initialize (&generic_head, &bitmap_default_obstack); 9086169689Skan bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 9087169689Skan bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 9088169689Skan 9089169689Skan for (pc = &clauses, c = clauses; c ; c = *pc) 9090169689Skan { 9091169689Skan bool remove = false; 9092169689Skan bool need_complete = false; 9093169689Skan bool need_implicitly_determined = false; 9094169689Skan 9095169689Skan switch (OMP_CLAUSE_CODE (c)) 9096169689Skan { 9097169689Skan case OMP_CLAUSE_SHARED: 9098169689Skan name = "shared"; 9099169689Skan need_implicitly_determined = true; 9100169689Skan goto check_dup_generic; 9101169689Skan 9102169689Skan case OMP_CLAUSE_PRIVATE: 9103169689Skan name = "private"; 9104169689Skan need_complete = true; 9105169689Skan need_implicitly_determined = true; 9106169689Skan goto check_dup_generic; 9107169689Skan 9108169689Skan case OMP_CLAUSE_REDUCTION: 9109169689Skan name = "reduction"; 9110169689Skan need_implicitly_determined = true; 9111169689Skan t = OMP_CLAUSE_DECL (c); 9112169689Skan if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 9113169689Skan || POINTER_TYPE_P (TREE_TYPE (t))) 9114169689Skan { 9115169689Skan error ("%qE has invalid type for %<reduction%>", t); 9116169689Skan remove = true; 9117169689Skan } 9118169689Skan else if (FLOAT_TYPE_P (TREE_TYPE (t))) 9119169689Skan { 9120169689Skan enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 9121169689Skan const char *r_name = NULL; 9122169689Skan 9123169689Skan switch (r_code) 9124169689Skan { 9125169689Skan case PLUS_EXPR: 9126169689Skan case MULT_EXPR: 9127169689Skan case MINUS_EXPR: 9128169689Skan break; 9129169689Skan case BIT_AND_EXPR: 9130169689Skan r_name = "&"; 9131169689Skan break; 9132169689Skan case BIT_XOR_EXPR: 9133169689Skan r_name = "^"; 9134169689Skan break; 9135169689Skan case BIT_IOR_EXPR: 9136169689Skan r_name = "|"; 9137169689Skan break; 9138169689Skan case TRUTH_ANDIF_EXPR: 9139169689Skan r_name = "&&"; 9140169689Skan break; 9141169689Skan case TRUTH_ORIF_EXPR: 9142169689Skan r_name = "||"; 9143169689Skan break; 9144169689Skan default: 9145169689Skan gcc_unreachable (); 9146169689Skan } 9147169689Skan if (r_name) 9148169689Skan { 9149169689Skan error ("%qE has invalid type for %<reduction(%s)%>", 9150169689Skan t, r_name); 9151169689Skan remove = true; 9152169689Skan } 9153169689Skan } 9154169689Skan goto check_dup_generic; 9155169689Skan 9156169689Skan case OMP_CLAUSE_COPYPRIVATE: 9157169689Skan name = "copyprivate"; 9158169689Skan goto check_dup_generic; 9159169689Skan 9160169689Skan case OMP_CLAUSE_COPYIN: 9161169689Skan name = "copyin"; 9162169689Skan t = OMP_CLAUSE_DECL (c); 9163169689Skan if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 9164169689Skan { 9165169689Skan error ("%qE must be %<threadprivate%> for %<copyin%>", t); 9166169689Skan remove = true; 9167169689Skan } 9168169689Skan goto check_dup_generic; 9169169689Skan 9170169689Skan check_dup_generic: 9171169689Skan t = OMP_CLAUSE_DECL (c); 9172169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9173169689Skan { 9174169689Skan error ("%qE is not a variable in clause %qs", t, name); 9175169689Skan remove = true; 9176169689Skan } 9177169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9178169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 9179169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 9180169689Skan { 9181169689Skan error ("%qE appears more than once in data clauses", t); 9182169689Skan remove = true; 9183169689Skan } 9184169689Skan else 9185169689Skan bitmap_set_bit (&generic_head, DECL_UID (t)); 9186169689Skan break; 9187169689Skan 9188169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 9189169689Skan name = "firstprivate"; 9190169689Skan t = OMP_CLAUSE_DECL (c); 9191169689Skan need_complete = true; 9192169689Skan need_implicitly_determined = true; 9193169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9194169689Skan { 9195169689Skan error ("%qE is not a variable in clause %<firstprivate%>", t); 9196169689Skan remove = true; 9197169689Skan } 9198169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9199169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 9200169689Skan { 9201169689Skan error ("%qE appears more than once in data clauses", t); 9202169689Skan remove = true; 9203169689Skan } 9204169689Skan else 9205169689Skan bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 9206169689Skan break; 9207169689Skan 9208169689Skan case OMP_CLAUSE_LASTPRIVATE: 9209169689Skan name = "lastprivate"; 9210169689Skan t = OMP_CLAUSE_DECL (c); 9211169689Skan need_complete = true; 9212169689Skan need_implicitly_determined = true; 9213169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 9214169689Skan { 9215169689Skan error ("%qE is not a variable in clause %<lastprivate%>", t); 9216169689Skan remove = true; 9217169689Skan } 9218169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 9219169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 9220169689Skan { 9221169689Skan error ("%qE appears more than once in data clauses", t); 9222169689Skan remove = true; 9223169689Skan } 9224169689Skan else 9225169689Skan bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 9226169689Skan break; 9227169689Skan 9228169689Skan case OMP_CLAUSE_IF: 9229169689Skan case OMP_CLAUSE_NUM_THREADS: 9230169689Skan case OMP_CLAUSE_SCHEDULE: 9231169689Skan case OMP_CLAUSE_NOWAIT: 9232169689Skan case OMP_CLAUSE_ORDERED: 9233169689Skan case OMP_CLAUSE_DEFAULT: 9234169689Skan pc = &OMP_CLAUSE_CHAIN (c); 9235169689Skan continue; 9236169689Skan 9237169689Skan default: 9238169689Skan gcc_unreachable (); 9239169689Skan } 9240169689Skan 9241169689Skan if (!remove) 9242169689Skan { 9243169689Skan t = OMP_CLAUSE_DECL (c); 9244169689Skan 9245169689Skan if (need_complete) 9246169689Skan { 9247169689Skan t = require_complete_type (t); 9248169689Skan if (t == error_mark_node) 9249169689Skan remove = true; 9250169689Skan } 9251169689Skan 9252169689Skan if (need_implicitly_determined) 9253169689Skan { 9254169689Skan const char *share_name = NULL; 9255169689Skan 9256169689Skan if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 9257169689Skan share_name = "threadprivate"; 9258169689Skan else switch (c_omp_predetermined_sharing (t)) 9259169689Skan { 9260169689Skan case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 9261169689Skan break; 9262169689Skan case OMP_CLAUSE_DEFAULT_SHARED: 9263169689Skan share_name = "shared"; 9264169689Skan break; 9265169689Skan case OMP_CLAUSE_DEFAULT_PRIVATE: 9266169689Skan share_name = "private"; 9267169689Skan break; 9268169689Skan default: 9269169689Skan gcc_unreachable (); 9270169689Skan } 9271169689Skan if (share_name) 9272169689Skan { 9273169689Skan error ("%qE is predetermined %qs for %qs", 9274169689Skan t, share_name, name); 9275169689Skan remove = true; 9276169689Skan } 9277169689Skan } 9278169689Skan } 9279169689Skan 9280169689Skan if (remove) 9281169689Skan *pc = OMP_CLAUSE_CHAIN (c); 9282169689Skan else 9283169689Skan pc = &OMP_CLAUSE_CHAIN (c); 9284169689Skan } 9285169689Skan 9286169689Skan bitmap_obstack_release (NULL); 9287169689Skan return clauses; 9288169689Skan} 9289